diff --git a/LICENSE b/LICENSE new file mode 100644 index 0000000000000000000000000000000000000000..261eeb9e9f8b2b4b0d119366dda99c6fd7d35c64 --- /dev/null +++ b/LICENSE @@ -0,0 +1,201 @@ + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. diff --git a/README.md b/README.md index 6ddff2f305ace52cf0365e74625592c1a32ac0be..ec3736143e83f462ce81a8b6fa19bed8261478e9 100644 --- a/README.md +++ b/README.md @@ -1,3 +1,497 @@ ---- -license: gpl-3.0 ---- +# Mistral-finetune + + + Open In Colab + + + +`mistral-finetune` is a light-weight codebase that enables memory-efficient and performant finetuning of Mistral's models. +It is based on [LoRA](https://arxiv.org/abs/2106.09685), a training paradigm where most weights are frozen and only 1-2% additional weights in the form of low-rank matrix perturbations are trained. + +For maximum efficiency it is recommended to use a A100 or H100 GPU. The codebase is optimized +for multi-GPU-single-node training setups, but for smaller models, such as the 7B a single GPU suffices. + +> **Note** +> +> - The goal of this repository is to provide a simple, guided entrypoint to finetune Mistral models. +> As such, it is fairly opinionated (especially around data formatting) and does not aim at being exhaustive +> across multiple model architecture or hardware types. +> For more generic approaches, you can check out some other great projects like +> [torchtune](https://pytorch.org/torchtune/stable/overview.html). + +## Installation + +To get started with Mistral LoRA fine-tuning, follow these steps: + +1. Clone this repository: +``` +cd $HOME && git clone https://github.com/mistralai/mistral-finetune.git +``` + +2. Install all required dependencies: +``` +cd mistral-finetune +pip install -r requirements.txt +``` + +## Model download + +We recommend fine-tuning one of the official Mistral models which you can download here: + +| Model | Link | Checksum | +|----------------|---------------------------------------------------------------------------------------------------------|-----------------------------------| +| 7B Base V3 | [7B Base](https://models.mistralcdn.com/mistral-7b-v0-3/mistral-7B-v0.3.tar) | `0663b293810d7571dad25dae2f2a5806`| +| 7B Instruct v3 | [7B Instruct v3](https://models.mistralcdn.com/mistral-7b-v0-3/mistral-7B-Instruct-v0.3.tar) | `80b71fcb6416085bcb4efad86dfb4d52`| +| 8x7B Base V1 | [8x7B Base](https://huggingface.co/mistralai/Mixtral-8x7B-v0.1) | (HF link) | +| 8x7B Instruct V1 | [8x7B Instruct](https://models.mistralcdn.com/mixtral-8x7b-v0-1/Mixtral-8x7B-v0.1-Instruct.tar) | `8e2d3930145dc43d3084396f49d38a3f` | +| 8x22 Instruct V3 | [8x22 Instruct](https://models.mistralcdn.com/mixtral-8x22b-v0-3/mixtral-8x22B-Instruct-v0.3.tar) | `471a02a6902706a2f1e44a693813855b`| +| 8x22B Base V3 | [8x22B Base](https://models.mistralcdn.com/mixtral-8x22b-v0-3/mixtral-8x22B-v0.3.tar) | `a2fa75117174f87d1197e3a4eb50371a`| + +**Important Notice**: For 8x7B Base V1 and 8x7B Instruct V1, it is necessary to use our v3 tokenizer and extend the vocabulary size to 32768 prior to fine-tuning. For detailed instructions on this process, please refer to the ["Model extension"](https://github.com/mistralai/mistral-finetune?tab=readme-ov-file#model-extension) section. + +E.g., to download the 7B-base model you can run the following command: +```sh +mkdir -p ~/${HOME}/mistral_models +cd ${HOME} && wget https://models.mistralcdn.com/mistral-7b-v0-3/mistral-7B-v0.3.tar +tar -xf mistral-7B-v0.3.tar -C mistral_models +``` + +Make sure to modify your training script and add the path to the downloaded +folder as `model_id_or_path`. + +E.g., modify [example/7B.yaml](https://github.com/mistralai/mistral-finetune/blob/main/example/7B.yaml) to include the absolute path to `$HOME/mistral_models/7B`: + +``` +model_id_or_path: "/Users/johndoe/mistral_models/7B" +``` + +## Prepare dataset + +To ensure effective training, `mistral-finetune` has strict +requirements for how the training data has to be formatted. + +All data files must be stored in jsonl format files. + +You can build two types of data files: + +### _Pretrain_: + +Pretrain data corresponds to plain text data stored in the `"text"` key. E.g: + +```jsonl +{"text": "Text contained in document n°1"} +{"text": "Text contained in document n°2"} +``` + +### _Instruct_: + +Currently two different types of instruction following data are supported: + +- _Instruct_: conversational data stored in the `"messages"` key in the form of a list. Each list item is a dictionary containing the `"content"` and `"role"` keys. `"role"` is a string being one of "user", "assistant" or "system_prompt". The loss will only be computed if "role" == "assistant". E.g.: + +```jsonl +{ + "messages": [ + { + "role": "user", + "content": "User interaction n°1 contained in document n°1" + }, + { + "role": "assistant", + "content": "Bot interaction n°1 contained in document n°1" + }, + { + "role": "user", + "content": "User interaction n°2 contained in document n°1" + }, + { + "role": "assistant", + "content": "Bot interaction n°2 contained in document n°1" + } + ] +} +{ + "messages": [ + { + "role": "user", + "content": "User interaction n°1 contained in document n°2" + }, + { + "role": "assistant", + "content": "Bot interaction n°1 contained in document n°2" + }, + { + "role": "user", + "content": "User interaction n°2 contained in document n°2" + }, + { + "role": "assistant", + "content": "Bot interaction n°2 contained in document n°2", + "weight": 0, # don't train on n°2 + }, + { + "role": "user", + "content": "User interaction n°3 contained in document n°2" + }, + { + "role": "assistant", + "content": "Bot interaction n°3 contained in document n°2" + } + ] +} +``` + +- _Function calling_: conversational data stored in the `"messages"` key in the form of a list. Each list item is a dictionary containing the `"role"` and `"content"` or `"tool_calls"` keys. `"role"` is a string being one of "user", "assistant", "system_prompt", or "tool". The loss will only be computed if "role" == "assistant". + +**Note**: In function calling the `"id"` of `"tool_calls"` and the `"tool_call_id"` are randomly generated strings of exactly 9 chars. We recommend to generate this automatically +in a data preparation script as is done [here](https://github.com/mistralai/mistral-finetune/blob/208b25c0f7299bb78d06cea25b82adee03834319/utils/reformat_data_glaive.py#L74). + +E.g.: + +```jsonl +{ + "messages": [ + { + "role": "system", + "content": "You are an helpful assistant who has access to the following functions to help the user, you can use the functions if needed" + }, + { + "role": "user", + "content": "Can you help me generate an anagram of the word \"listen\"?" + }, + { + "role": "assistant", + "tool_calls": [ + { + "id": "TX92Jm8Zi", + "type": "function", + "function": { + "name": "generate_anagram", + "arguments": "{\"word\": \"listen\"}" + } + } + ] + }, + { + "role": "tool", + "content": "{\"anagram\": \"silent\"}", + "tool_call_id": "TX92Jm8Zi" + }, + { + "role": "assistant", + "content": "The anagram of the word \"listen\" is \"silent\"." + }, + { + "role": "user", + "content": "That's amazing! Can you generate an anagram for the word \"race\"?" + }, + { + "role": "assistant", + "tool_calls": [ + { + "id": "3XhQnxLsT", + "type": "function", + "function": { + "name": "generate_anagram", + "arguments": "{\"word\": \"race\"}" + } + } + ] + } + ], + "tools": [ + { + "type": "function", + "function": { + "name": "generate_anagram", + "description": "Generate an anagram of a given word", + "parameters": { + "type": "object", + "properties": { + "word": { + "type": "string", + "description": "The word to generate an anagram of" + } + }, + "required": [ + "word" + ] + } + } + } + ] +} +``` + +## Verify dataset + +Before starting a training run you should verify that your dataset is correctly formatted and get an +estimation of the training time. You can do so by using the [./utils/validate_data](https://github.com/mistralai/mistral-finetune/blob/main/utils/validate_data.py) script. + +Note that this step is crucial to ensure that the data is correctly formatted. + +### Instruction following + +Let's go over a simple example to train a model in instruction following: + +- 1. **Load a chunk of [Ultachat_200k](https://huggingface.co/datasets/HuggingFaceH4/ultrachat_200k)** + +Create the data folder and navigate to the folder. +```sh +cd $HOME && mkdir -p data && cd $HOME/data +``` + +Load the data into a Pandas Dataframe. + +**Note**: Make sure to have pandas and pyarrow installed (`pip install pandas pyarrow`). + +```py +import pandas as pd + +df = pd.read_parquet('https://huggingface.co/datasets/HuggingFaceH4/ultrachat_200k/resolve/main/data/test_gen-00000-of-00001-3d4cd8309148a71f.parquet') +``` +- 2. Split into train and eval + +```py +df_train=df.sample(frac=0.95,random_state=200) +df_eval=df.drop(df_train.index) +``` + +- 3. Save data to jsonl + +```py +df_train.to_json("ultrachat_chunk_train.jsonl", orient="records", lines=True) +df_eval.to_json("ultrachat_chunk_eval.jsonl", orient="records", lines=True) +``` + +- 4. Modify your training yaml to include the ultrachat dataset and verify the yaml + +Modify [example/7B.yaml](https://github.com/mistralai/mistral-finetune/blob/main/example/7B.yaml) to include the absolute path to `$HOME/data/ultrachat_chunk_train.jsonl` as well as a dataset mixing weight for training and `$HOME/data/ultrachat_chunk_eval.jsonl` for eval, *e.g.* + +``` +data: + instruct_data: "/Users/johndoe/data/ultrachat_chunk_train.jsonl" + eval_instruct_data: "/Users/johndoe/data/ultrachat_chunk_eval.jsonl" +``` + +Now you can verify your training yaml to make sure the data is correctly formatted and to get an estimate of your training time. + +``` +cd $HOME/mistral-finetune +python -m utils.validate_data --train_yaml example/7B.yaml +``` + +Upon completion you should see an error report with many of the following errors: + +``` +The data in line 1412 of dataset /Users/johndoe/data/ultrachat_chunk_eval.jsonl is incorrectly formated.Expected last role to be one of: [assistant] but got user +The data in line 1413 of dataset /Users/johndoe/data/ultrachat_chunk_eval.jsonl is incorrectly formated.Expected last role to be one of: [assistant] but got user +The data in line 1414 of dataset /Users/johndoe/data/ultrachat_chunk_eval.jsonl is incorrectly formated.Expected last role to be one of: [assistant] but got user +The data in line 1415 of dataset /Users/johndoe/data/ultrachat_chunk_eval.jsonl is incorrectly formated.Expected last role to be one of: [assistant] but got user +``` + +Many conversations seem to end with the 'user' role which is unnecessary as we only train on 'assistant' messages and thus would unnecessarily process data. + +You can make use of [./utils/reformat_data.py](https://github.com/mistralai/mistral-finetune/blob/main/utils/reformat_data.py) to correct the data: + +``` +cd $HOME/mistral-finetune +python -m utils.reformat_data $HOME/data/ultrachat_chunk_train.jsonl +python -m utils.reformat_data $HOME/data/ultrachat_chunk_eval.jsonl +``` + +You should see that a couple of samples will be skipped. + +- 5. Potentially change number of training steps + +Upon correction of the dataset, run the script again + +``` +cd $HOME/mistral-finetune +python -m utils.validate_data --train_yaml example/7B.yaml +``` + +You should get a summary of the data input and training parameters: + +``` +Train States + -------------------- +{ + "expected": { + "eta": "00:52:44", + "data_tokens": 25169147, + "train_tokens": 131072000, + "epochs": "5.21", + "max_steps": 500, + "data_tokens_per_dataset": { + "/Users/johndoe/data/ultrachat_chunk_train.jsonl": "25169147.0" + }, + "train_tokens_per_dataset": { + "/Users/johndoe/data/ultrachat_chunk_train.jsonl": "131072000.0" + }, + "epochs_per_dataset": { + "/Users/johndoe/data/ultrachat_chunk_train.jsonl": "5.2" + } + }, +} +``` + +Having `max_steps` set to 500 would lead to iterating through the dataset roughly 5 times which is reasonable, but might +be a bit too much. A recommended setting is shown below which would only take 30min on a 8xH100 cluster. + +### Function calling + +Next let's go over a more advanced use case to fine-tune a model on function calling. +Function calling requires the data to be in the format as [explained above](#instruct). Let's go over an example. + +- 1. **Load a chat-formatted version of the [Glaive function calling dataset](https://huggingface.co/datasets/Locutusque/function-calling-chatml)** + +Create the data folder and navigate to the folder. +```sh +cd $HOME && mkdir -p data && cd $HOME/data +``` + +Load the data into a Pandas Dataframe. + +**Note**: Make sure to have pandas and pyarrow installed (`pip install pandas pyarrow`). + +```py +import pandas as pd + +df = pd.read_parquet('https://huggingface.co/datasets/Locutusque/function-calling-chatml/resolve/main/data/train-00000-of-00001-f0b56c6983b4a78f.parquet') +``` +- 2. Split into train and eval + +```py +df_train=df.sample(frac=0.95,random_state=200) +df_eval=df.drop(df_train.index) +``` + +- 3. Save data to jsonl + +```py +df_train.to_json("glaive_train.jsonl", orient="records", lines=True) +df_eval.to_json("glaive_eval.jsonl", orient="records", lines=True) +``` + +- 4. Reformat dataset + +As one can see the dataset does not follow the required function calling format, so it will need to be reformatted. Among other things `"from"` should be renamed to `"user"` and superfluous `"\n"` characters should be removed. +For this dataset you can make use of [`./utils/reformat_data_glaive.py`](https://github.com/mistralai/mistral-finetune/blob/main/utils/reformat_data_glaive.py): + +``` +cd $HOME/mistral-finetune +python -m utils.reformat_data_glaive $HOME/data/glaive_train.jsonl +python -m utils.reformat_data_glaive $HOME/data/glaive_eval.jsonl +``` + +Running this command will make sure that most samples are in the correct format. + +**Note**: It is impossible to write reformatting scripts that work for all kinds of datasets. +If you have datasets that don't yet follow the required format above, you will most probably have to +create a reformatting script yourself (mistral-chat or chat-gpt is your best friend here!). + +- 5. Validate dataset + +You can now validate the dataset by setting `data.instruct_data` and `data.eval_instruct_data` to +`$HOME/data/glaive_train.jsonl` and `$HOME/data/glaive_eval.jsonl` in `example/7B.yaml` respectively. + +The reformatted datasets still has some errors which can be removed with `--create_corrected`. For this, make sure to add +`--create_corrected` as follows: + +``` +cd $HOME/mistral-finetune +python -m utils.validate_data --train_yaml example/7B.yaml --create_corrected +``` + +Running this command will show a couple of errors and save two new datasets `$HOME/data/glaive_train.jsonl.corrected` and `$HOME/data/glaive_eval.jsonl.corrected`. Make sure to use these two dataset in `example/7B.yaml` and run the command again. Now the dataset should be correctly formatted! + + +## Start training + +Having followed the [dataset verification section](#verify-dataset), we can now start training. +For faster training, we recommend setting max_steps to only 300. Make sure to define `run_dir` to your experiment folder and optionally set `wandb_project` to a Weights & Biases project for logging`, *e.g.*: +``` +max_steps: 300 +run_dir: "/Users/johndoe/ultra_chat_test" +wandb.project: ultra_chat +``` + +Optionally you can also set `wandb` + +Save the training configuration and start training! Make sure to set `--nproc-per-node` to the number of available GPUs. + +``` +cd $HOME/mistral-finetune +torchrun --nproc-per-node 8 --master_port $RANDOM -m train example/7B.yaml +``` + +Training on ultra-chat should take around 30min on a 8xH100 node and the resulting weights should give an MT Bench score around 6.3. + +Training on glaive should take around 1h on a 8xH100 node and the resulting weights should work nicely for function calling. + +## Customizing training configuration + +The example `mistral-finetune/examples/7B` defines reasonable parameters for learning rate, weight decay, etc... but you are advised to +customize these settings for your use case. + +Generally, a training configuration should fill the following parameters: + +- `model_id_or_path` defines the model to start training from. This can be a path to a pre-trained model or a local model directory. +- `run_dir` defines the directory where training checkpoints and metrics are stored. +- `seq_len` defines the sequence length for training. This is the maximum length of input sequences the model will process. Samples are packed to reach a length of `seq_len` for maximum training efficiency. +- `batch_size` defines the number of training examples used per GPU. **Note**: The overall effective batch_size (in tokens) across all GPUs equals `num_gpus` x `batch_size` x `seq_len`. +- `max_steps` defines the maximum number of training steps. This is the total number of iterations the training process will run. It can be adjusted based on the specific needs of your training scenario. Total number of tokens seen during training is `max_steps` x `num_gpus` x `batch_size` x `seq_len`. +- `optim.lr` defines the learning rate. This is the initial learning rate for the optimizer. +- `optim.weight_decay` defines weight decay. Weight decay is a regularization technique used to prevent overfitting by penalizing large weights. We recommend leaving it at 0.1. +- `optim.pct_start` defines the percentage of the total training steps used for the learning rate warm-up phase before it starts to decrease. It corresponds to pct_start of PyTorch's OneCycleLR. +- `lora.rank` defines the size of the LoRA (Low-Rank Adaptation) adapters. We recommend 64 or less, which adjusts the rank of the low-rank decomposition used in LoRA. +- `seed` defines the random seed for initialization and data shuffling/sampling. Setting a seed ensures reproducibility of results. +- `log_freq` defines the logging frequency. This specifies how often (in steps) to log training metrics. +- `data.instruct_data` is the path to the instruction data used for training. This field has to be filled with one or multiple data sources in the format as explained above. Each data source should either be a path to jsonl file of a path to a directory containing jsonl files followed by a weighting to define the importance of this dataset: `:`. E.g.: `data.instruct_data: "/path/to/data1.jsonl:5.,/path/to/data2.jsonl:1.,/path/to/dir_of_jsonls:1."` +- `data.data` is an optional path to additional pretraining data in the format as explained above. Note that this field can be left blank. +- `data.eval_instruct_data` is an optional path to evaluation instruction data to run cross-validation at every `eval_freq` steps. Cross-validation metrics are displayed as `loss` and `perplexity`. +- `eval_freq` defines how often (in steps) to evaluate the model. This specifies the interval at which the model is evaluated on the validation set. +- `no_eval` is a flag to enable or disable intermediate evaluation. Setting it to False enables periodic evaluation during training. +- `ckpt_freq` defines how often (in steps) to save checkpoints. This specifies the interval at which the model's state is saved. +- `ckpt_only_lora` defines whether to only save the trained LoRA checkpoints or whether the trained LoRA should directly be merged into the base model and saved. **Note**: When setting `ckpt_only_lora=False` make sure that you have enough CPU and GPU memory to save the full model on a single process (this is usually only possible for the 7B model). +- `wandb.key` is used to pass your Weights & Biases (wandb) API key for logging. This allows you to log training metrics to the wandb dashboard. +- `wandb.project` defines the wandb project name. This is where the training run will be logged in the wandb interface. + +## Inference + +Once your model is trained, you should try it out in inference. We recommend using [mistral-inference](https://github.com/mistralai/mistral-inference). + +Make sure to have `mistral_inference` correctly installed: +``` +pip install mistral_inference +``` + +Assuming your `lora.safetensors` is saved under `$HOME/ultra_chat_test/checkpoints/checkpoint_000300/consolidated/lora.safetensors`, you can chat with the model using `mistral_inference`, *e.g.*: + +```sh +mistral-chat /mnt/slow/runs/patrick/mistral-finetune/7B/ --max_tokens 256 --temperature 1.0 --instruct --lora_path $HOME/ultra_chat_test/checkpoints/checkpoint_000300/consolidated/lora.safetensors +``` + +## Model extension + +**Important**: Note that one can only fine-tune mistral models that are compatible with the v3 tokenizer which entails that the models have a vocabulary size of 32768 - not 32000. One can however easily extend older version of vocabulary size 32000 to have a vocabulary size of 32768 by using: +``` +python -m utils.extend_model_vocab --original_model_ckpt /folder/to/old/model --extended_model_ckpt /folder/to/extended/model +``` + +Once the extension has worked, one can fine-tune using the newly created model checkpoint in `/folder/to/extended/model`. + +## FAQ: + +> - What's the best practice of fine-tuning MoEs? + +We see a higher degree of performance variance in when fine-tuning MoE models. It's not unusual to find that fine-tuning MoEs models with different seeds can lead to a high variance in performance. We did not observe such a high variance with dense models. Therefore, we suggest running multiple instances of the same fine-tuning process on MoEs models and selecting the one that performs best. + +> - How can I determine the number of tokens used during the model training process? + +You can use the following script to find out: https://github.com/mistralai/mistral-finetune/blob/main/utils/validate_data.py. This script accepts a .yaml training file as input and returns the number of tokens the model is being trained on. + +> - What should I do if I encounter a CUDA out-of-memory error? + +One possible solution is to reduce the batch size per GPU. The batch size is equal to `seq_len` x `batch_size`. Try setting `batch_size` to 1 and reduce `seq_len`. You can define the `batch_size` and `seq_len` in the .yaml file. diff --git a/__pycache__/train.cpython-310.pyc b/__pycache__/train.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d7ebb01f67b8dc0bc108487b884ddd2d9c924117 Binary files /dev/null and b/__pycache__/train.cpython-310.pyc differ diff --git a/example/7B.yaml b/example/7B.yaml new file mode 100644 index 0000000000000000000000000000000000000000..65f8ef2c601536dab05ce5f81bb08bcb99cfc118 --- /dev/null +++ b/example/7B.yaml @@ -0,0 +1,37 @@ +# data +data: + instruct_data: "/root/data/mol_instructions_train.jsonl" # Fill this with the path to your training data + data: "" # Optionally fill with pretraining data + eval_instruct_data: "" # Optionally fill with evaluation data + +# model +model_id_or_path: "/root/mistral_models/7B-v0.3" # Path to downloaded model +lora: + rank: 64 + +# optim +seq_len: 32768 +batch_size: 2 + #TODO try other values +max_steps: 500 +optim: + lr: 5.e-5 + weight_decay: 0.05 + pct_start: 0.05 + +# other +seed: 99 +log_freq: 1 +eval_freq: 100 +no_eval: True +ckpt_freq: 100 + +ckpt_only_lora: False # Save only trained LoRA adapters. Set to `False` to merge LoRA adapter into the base model and save full fine-tuned model + +run_dir: "/root/mistral-finetune/runseed99" + +wandb: + project: "CHEMISTral7b-ft" + offline: False # Set to True if you want to use wandb in offline mode + key: "aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df" # Optionally set your WandB API key + run_name: "runseed99" # Optionally name your WandB run diff --git a/finetune/__init__.py b/finetune/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/finetune/__pycache__/__init__.cpython-310.pyc b/finetune/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cc980511724a20715ed130bda0fdac04c8a13c8e Binary files /dev/null and b/finetune/__pycache__/__init__.cpython-310.pyc differ diff --git a/finetune/__pycache__/__init__.cpython-38.pyc b/finetune/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b4b14f1d463d3258bc697dd25728556667d94588 Binary files /dev/null and b/finetune/__pycache__/__init__.cpython-38.pyc differ diff --git a/finetune/__pycache__/args.cpython-310.pyc b/finetune/__pycache__/args.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b620c144c286fad85b8fe84171fb5d36e9f965dd Binary files /dev/null and b/finetune/__pycache__/args.cpython-310.pyc differ diff --git a/finetune/__pycache__/args.cpython-38.pyc b/finetune/__pycache__/args.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ad6a524918f5652c5cc1555c1e12801a25960753 Binary files /dev/null and b/finetune/__pycache__/args.cpython-38.pyc differ diff --git a/finetune/__pycache__/checkpointing.cpython-310.pyc b/finetune/__pycache__/checkpointing.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..db27734db7d42649b64db5b9007f7d32c59544f0 Binary files /dev/null and b/finetune/__pycache__/checkpointing.cpython-310.pyc differ diff --git a/finetune/__pycache__/checkpointing.cpython-38.pyc b/finetune/__pycache__/checkpointing.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cdf62e211583386283517f1462252604daabc149 Binary files /dev/null and b/finetune/__pycache__/checkpointing.cpython-38.pyc differ diff --git a/finetune/__pycache__/distributed.cpython-310.pyc b/finetune/__pycache__/distributed.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..ab497ed73f20fe24bc550841ff12ef150fd83916 Binary files /dev/null and b/finetune/__pycache__/distributed.cpython-310.pyc differ diff --git a/finetune/__pycache__/distributed.cpython-38.pyc b/finetune/__pycache__/distributed.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4538f63c416746331a8712c3d0531a379c649d12 Binary files /dev/null and b/finetune/__pycache__/distributed.cpython-38.pyc differ diff --git a/finetune/__pycache__/eval.cpython-310.pyc b/finetune/__pycache__/eval.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..f9e9e89c6e33e90c48a599c050d09b4fe4e9fb49 Binary files /dev/null and b/finetune/__pycache__/eval.cpython-310.pyc differ diff --git a/finetune/__pycache__/loss.cpython-310.pyc b/finetune/__pycache__/loss.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..becf6e0b948f0588f1fab0db2c307c90cf94e7b5 Binary files /dev/null and b/finetune/__pycache__/loss.cpython-310.pyc differ diff --git a/finetune/__pycache__/mixed_precision.cpython-310.pyc b/finetune/__pycache__/mixed_precision.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2bc0596e58e2d6d495351b2b187481c1f54966ff Binary files /dev/null and b/finetune/__pycache__/mixed_precision.cpython-310.pyc differ diff --git a/finetune/__pycache__/utils.cpython-310.pyc b/finetune/__pycache__/utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..650ff32e65109d20860843838e9208fe2e144587 Binary files /dev/null and b/finetune/__pycache__/utils.cpython-310.pyc differ diff --git a/finetune/__pycache__/wrapped_model.cpython-310.pyc b/finetune/__pycache__/wrapped_model.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..82467e5f7c42ee13714f73fe96c2371cb5721b68 Binary files /dev/null and b/finetune/__pycache__/wrapped_model.cpython-310.pyc differ diff --git a/finetune/args.py b/finetune/args.py new file mode 100644 index 0000000000000000000000000000000000000000..5290917901746f4986ab888e24ef63acac6aebb4 --- /dev/null +++ b/finetune/args.py @@ -0,0 +1,116 @@ +import logging +import os +from dataclasses import dataclass, field +from pathlib import Path +from typing import Optional + +from simple_parsing.helpers import Serializable + +from model.args import LoraArgs + +from .data.args import DataArgs + + +@dataclass +class OptimArgs(Serializable): + lr: float = 3e-4 + weight_decay: float = 0.1 + pct_start: float = 0.3 + + +@dataclass +class WandbArgs(Serializable): + project: Optional[str] = None # Fill this argument to use wandb. + offline: bool = False + key: Optional[str] = None + run_name: Optional[str] = None + + def __post_init__(self) -> None: + if self.project is not None: + try: + import wandb # noqa: F401 + except ImportError: + raise ImportError("`wandb` not installed. Either make sure `wandb` is installed or set `wandb:project` to None.") + + if len(self.project) == 0: + raise ValueError("`wandb.project` must not be an empty string.") + +@dataclass +class MLFlowArgs(Serializable): + tracking_uri: Optional[str] = None + experiment_name: Optional[str] = None + + def __post_init__(self) -> None: + if self.tracking_uri is not None: + try: + import mlflow # noqa: F401 + except ImportError: + raise ImportError("`mlflow` not installed. Either make sure `mlflow` is installed or set `mlflow.tracking_uri` to None.") + + if self.experiment_name is None: + raise ValueError("If `mlflow.tracking_uri` is set, `mlflow.experiment_name` must be set as well.") + + + +@dataclass +class TrainArgs(Serializable): + data: DataArgs + + # if specified, instruct_tokenizer and model will be loaded + model_id_or_path: str # Path to the directory containing the initial model or model id: "mistral-small" + + run_dir: str # Path to the directory where everything will be saved. It needs to be empty. + # Name of the wandb run, if None it will be set to the name of the run_dir. + + optim: OptimArgs = field(default_factory=OptimArgs) + seed: int = 0 + # Number of steps to accumulate gradients before calling doing an optimizer step. + num_microbatches: int = 1 + + seq_len: int = 2048 # Number of tokens per batch per device. + batch_size: int = 1 + max_norm: float = 1.0 # Gradient clipping. + max_steps: int = 100 # Number of training steps. + log_freq: int = 1 # Number of steps between each logging. + + # Number of steps between each checkpoint saving. If inferior to 1, only the last checkpoint will be saved. + ckpt_freq: int = 0 + ckpt_only_lora: bool = True + # If True, no checkpoint will be saved. This is useful for development. + no_ckpt: bool = False + num_ckpt_keep: Optional[int] = 3 + eval_freq: int = 0 + no_eval: bool = True + + # Efficiency + # Determines whether gradient checkpointing should be utilized or not during the training process. Gradient checkpointing can be beneficial in reducing memory usage at the cost of slightly longer training times. + checkpoint: bool = True + + world_size: Optional[int] = field(init=False, default=None) + + # logging + wandb: WandbArgs = field(default_factory=WandbArgs) + mlflow: MLFlowArgs = field(default_factory=MLFlowArgs) + + # LoRA + lora: Optional[LoraArgs] = field(default_factory=LoraArgs) + + def __post_init__(self) -> None: + assert getattr(self, "world_size", None) is None + self.world_size = int(os.environ.get("WORLD_SIZE", -1)) + + if self.wandb.offline: + command = f"cd {self.run_dir}; wandb sync --sync-all" + logging.info(f"to sync wandb offline, run: {command}") + + assert self.num_microbatches >= 1 + + assert self.num_ckpt_keep is None or self.num_ckpt_keep >= 1 + + if self.model_id_or_path is not None: + Path(self.model_id_or_path).exists() + + if not self.ckpt_only_lora: + logging.warning( + "You are have disabled `ckpt_only_lora` and are thus merging the trained LoRA checkpoint into the base model upon checkpointing. This might lead to OOM erros - make sure you have enough CPU and GPU memory." + ) diff --git a/finetune/checkpointing.py b/finetune/checkpointing.py new file mode 100644 index 0000000000000000000000000000000000000000..6e118e27f57aa1186a9512273559711b47dd28ae --- /dev/null +++ b/finetune/checkpointing.py @@ -0,0 +1,246 @@ +import json +import logging +import shutil +from pathlib import Path +from typing import Dict, List, Optional, Union + +import safetensors.torch +import torch +from mistral_common.tokens.tokenizers.sentencepiece import InstructTokenizerBase +from torch.distributed import barrier +from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel + +from model.transformer import LoRALinear + +from .distributed import get_rank, get_world_size +from .utils import TrainState + +logger = logging.getLogger("checkpointing") + + +def main_logger_info(message: str) -> None: + if get_rank() == 0: + logger.info(message) + + +class Checkpointer: + """A class to save PyTorch model and optimizer states""" + + def __init__( + self, + model: FullyShardedDataParallel, + state: TrainState, + run_dir: Union[Path, str], + optimizer: Optional[torch.optim.Optimizer] = None, + num_ckpt_keep: Optional[int] = None, + ): + self.model = model + self.optimizer = optimizer + self.state = state + self.run_dir = Path(run_dir) + self.rank = get_rank() + self.num_ckpt_keep = num_ckpt_keep + + @property + def ckpt_dir(self) -> Path: + return self.run_dir / "checkpoints" + + @property + def dst_dir(self) -> Path: + return self.ckpt_dir / f"checkpoint_{self.state.step:06d}" / "consolidated" + + @staticmethod + def consolidated_path( + ckpt_dir: Path, use_safetensors: bool, save_only_lora: Optional[bool] = False + ) -> Path: + suffix = "safetensors" if use_safetensors else "00.pth" + prefix = "lora" if save_only_lora else "consolidated" + + return ckpt_dir / f"{prefix}.{suffix}" + + @staticmethod + def _tmp(ckpt_dir: Path) -> Path: + return ckpt_dir.with_name(f"tmp.{ckpt_dir.name}") + + def write_params_info(self, tmp_dst: Path): + params_path = tmp_dst / "params.json" + with open(params_path, "w") as f: + model_args = self.model.args.to_dict() + + f.write(json.dumps(model_args, indent=4)) + + def delete_old_ckpts(self) -> List[Path]: + all_saved_ckpts = [d for d in self.ckpt_dir.iterdir() if d.is_dir()] + + # Sort directories by creation time (oldest to newest) + all_saved_ckpts.sort(key=lambda x: x.stat().st_ctime, reverse=True) + + ckpts_to_delete = all_saved_ckpts[self.num_ckpt_keep :] + + for ckpt_to_delete in ckpts_to_delete: + try: + shutil.rmtree(ckpt_to_delete) + main_logger_info(f"Deleted ckpt: {ckpt_to_delete}") + except OSError as e: + main_logger_info(f"Error deleting directory {ckpt_to_delete}: {e}") + + return ckpts_to_delete + + @staticmethod + def get_lora_states(state_dict: Dict[str, torch.Tensor]) -> Dict[str, torch.Tensor]: + return {k: v for k, v in state_dict.items() if "lora" in k} + + @staticmethod + def get_non_lora_states( + state_dict: Dict[str, torch.Tensor] + ) -> Dict[str, torch.Tensor]: + return { + k: v + for k, v in state_dict.items() + if not any(l_key in k for l_key in ["lora", "frozen"]) + } + + @torch.no_grad() + def retrieve_save_states( + self, save_only_lora: bool, save_dtype: torch.dtype + ) -> Dict[str, torch.Tensor]: + if save_only_lora: + assert ( + self.model.args.lora.enable + ), "Cannot save LoRA checkpoint as LoRA training is not enabled." + + # remove all potential hooks + for module in self.model.modules(): + if isinstance(module, LoRALinear) and hasattr(module, "_merge_lora_handle"): + module._merge_lora_handle.remove() # type: ignore + + # merge weights if we don't just save LoRA + if not save_only_lora: + + def merge_lora( + m: torch.nn.Module, + destination: Dict[str, torch.Tensor], + prefix: str, + *args, + ): + weight = m.merge_weight() # type: ignore + destination[prefix + "weight"] = weight + + for module in self.model.modules(): + if isinstance(module, LoRALinear): + module._merge_lora_handle = module._register_state_dict_hook( + merge_lora + ) + + offload_to_cpu = get_world_size() > 1 + if save_only_lora: + + def is_trainable_fsdp( + module: Union[torch.nn.Module, FullyShardedDataParallel] + ): + is_fsdp = isinstance(module, FullyShardedDataParallel) + all_params_have_grads = is_fsdp and all( + p.requires_grad is True for p in module.parameters() + ) + + # need to make sure only lowest fsdp wrap is used + is_leaf_node = is_fsdp and len(list(module.module.children())) == 0 # type: ignore + + return is_fsdp and all_params_have_grads and is_leaf_node + + # extract all modules with only trainable weights + modules = { + k: m for k, m in self.model.named_modules() if is_trainable_fsdp(m) + } + + states = {} + for key, module in modules.items(): + assert isinstance( + module, FullyShardedDataParallel + ), "`module` should be an instance of `FullyShardedDataParallel`" + parent_prefix = key.replace("_fsdp_wrapped_module.", "").replace( + "_checkpoint_wrapped_module.", "" + ) + with module.summon_full_params( + module, writeback=True, offload_to_cpu=offload_to_cpu + ): + states.update( + { + f"{parent_prefix}.{k}": v.to(dtype=save_dtype) + for k, v in module.state_dict().items() + } + ) + else: + # make sure you have enough CPU RAM available to save the full model + assert isinstance( + self.model, FullyShardedDataParallel + ), "`self.model` should be an instance of `FullyShardedDataParallel`" + with self.model.summon_full_params( + self.model, writeback=True, offload_to_cpu=offload_to_cpu + ): + states = self.get_non_lora_states(self.model.state_dict()) + states = {k: v.to(dtype=save_dtype) for k, v in states.items()} + + states = dict(sorted(states.items())) + return states + + @staticmethod + def save_tokenizer(instruct_tokenizer: InstructTokenizerBase, tmp_dst: Path): + serialized_spm = instruct_tokenizer.tokenizer._model.serialized_model_proto() # type: ignore + + tokenizer_path = tmp_dst / "tokenizer.model.v3" + + with open(tokenizer_path, "wb") as f: + f.write(serialized_spm) + + @torch.no_grad() + def save_checkpoint( + self, + save_only_lora: bool, + dtype: torch.dtype = torch.float16, + instruct_tokenizer: Optional[InstructTokenizerBase] = None, + ): + tmp_dst = self._tmp(self.dst_dir) + main_logger_info( + f"Dumping checkpoint in {self.dst_dir} using tmp name: {tmp_dst.name}" + ) + + assert not self.dst_dir.exists(), f"dst exists {self.dst_dir}" + tmp_dst.mkdir(parents=True, exist_ok=True) + + states: Dict[str, torch.Tensor] = self.retrieve_save_states( + save_only_lora, dtype + ) + + barrier() + + if self.rank == 0: + # save checkpoint in tmp path + safetensors.torch.save_file( + states, + self.consolidated_path( + tmp_dst, use_safetensors=True, save_only_lora=save_only_lora + ), # always use safetensors for checkpointing + ) + + self.write_params_info(tmp_dst) + + # save tokenizer + if instruct_tokenizer is not None: + self.save_tokenizer(instruct_tokenizer, tmp_dst) + + assert not self.dst_dir.exists(), f"should not happen! {self.dst_dir}" + tmp_dst.rename(self.dst_dir) + + logger.info( + f"Done dumping checkpoint in {self.dst_dir} for step: {self.state.step}" + ) + + # delete last n checkpoints + if self.num_ckpt_keep is not None: + ckpts_to_delete = self.delete_old_ckpts() + logger.info( + f"Done deleting checkpoints {', '.join([str(c) for c in ckpts_to_delete])}" + ) + + main_logger_info("Done!") diff --git a/finetune/data/__init__.py b/finetune/data/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/finetune/data/__pycache__/__init__.cpython-310.pyc b/finetune/data/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3c4d4183f03f04fe759db3ffd4a6745534f42694 Binary files /dev/null and b/finetune/data/__pycache__/__init__.cpython-310.pyc differ diff --git a/finetune/data/__pycache__/__init__.cpython-38.pyc b/finetune/data/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..127bb0de4e5c07b248945f17bf8d1d2736630ffb Binary files /dev/null and b/finetune/data/__pycache__/__init__.cpython-38.pyc differ diff --git a/finetune/data/__pycache__/args.cpython-310.pyc b/finetune/data/__pycache__/args.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..1260c446108a6cf5fe0d741c3886eef64934fba8 Binary files /dev/null and b/finetune/data/__pycache__/args.cpython-310.pyc differ diff --git a/finetune/data/__pycache__/args.cpython-38.pyc b/finetune/data/__pycache__/args.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e941117d244bdc5834400c144d0337ca409be112 Binary files /dev/null and b/finetune/data/__pycache__/args.cpython-38.pyc differ diff --git a/finetune/data/__pycache__/data_loader.cpython-310.pyc b/finetune/data/__pycache__/data_loader.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..84531a95e7fa8cd42edd110212bd2d9eea19f0d4 Binary files /dev/null and b/finetune/data/__pycache__/data_loader.cpython-310.pyc differ diff --git a/finetune/data/__pycache__/dataset.cpython-310.pyc b/finetune/data/__pycache__/dataset.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af14a41288a3ace18b1fe115a0750ce2bd97c294 Binary files /dev/null and b/finetune/data/__pycache__/dataset.cpython-310.pyc differ diff --git a/finetune/data/__pycache__/dataset.cpython-38.pyc b/finetune/data/__pycache__/dataset.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..80b1e21244f3e873ebc5b776eea61dfc55e0296b Binary files /dev/null and b/finetune/data/__pycache__/dataset.cpython-38.pyc differ diff --git a/finetune/data/__pycache__/exceptions.cpython-310.pyc b/finetune/data/__pycache__/exceptions.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c31b2178931f24ba469d6dc884d820ed80113599 Binary files /dev/null and b/finetune/data/__pycache__/exceptions.cpython-310.pyc differ diff --git a/finetune/data/__pycache__/exceptions.cpython-38.pyc b/finetune/data/__pycache__/exceptions.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..62ac245f29af5986a1ee0c6d719a70a3dbe59eb6 Binary files /dev/null and b/finetune/data/__pycache__/exceptions.cpython-38.pyc differ diff --git a/finetune/data/__pycache__/tokenize.cpython-310.pyc b/finetune/data/__pycache__/tokenize.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..af7462f263926da04cf6733195ce3fa60da5cf51 Binary files /dev/null and b/finetune/data/__pycache__/tokenize.cpython-310.pyc differ diff --git a/finetune/data/__pycache__/tokenize.cpython-38.pyc b/finetune/data/__pycache__/tokenize.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4bf076b934e4897c11a7aa23f1187c4ae93a2b1c Binary files /dev/null and b/finetune/data/__pycache__/tokenize.cpython-38.pyc differ diff --git a/finetune/data/args.py b/finetune/data/args.py new file mode 100644 index 0000000000000000000000000000000000000000..dd05cc389b1e226d6f52c97d9518cbefbc3308d5 --- /dev/null +++ b/finetune/data/args.py @@ -0,0 +1,61 @@ +import logging +from dataclasses import dataclass, field + +from simple_parsing.helpers import Serializable + +logger = logging.getLogger("data") + + +@dataclass() +class InstructArgs(Serializable): + shuffle: bool = True + + # For function calling training examples only the last tool call + # of the assistant message can be used for training. Therefore, + # we chunk longer function calling conversations into multiple + # training samples to not loose any data. E.g.: + # [[ + # UserMessage_1, AssisantToolCallMessage_1, ToolMessage_1, AssisantMessage_1 + # UserMessage_2, AssisantToolCallMessage_2, ToolMessage_2, AssisantMessage_2 + # ]] + # => is chunked into two training samples: + # [[ + # UserMessage_1, AssisantToolCallMessage_1, ToolMessage_1, AssisantMessage_1 + # ], + # [ + # UserMessage_1, AssisantToolCallMessage_1, ToolMessage_1, AssisantMessage_1 + # UserMessage_2, AssisantToolCallMessage_2, ToolMessage_2, AssisantMessage_2 + # ]] + # NOTE: Only if your data is already pre-chunked should this argument be set to False + dynamic_chunk_fn_call: bool = True + + +@dataclass() +class DataArgs(Serializable): + # The data arguments `data` and `instruct_data` are a string in the format + # "data_source_dir_1:weight_1,data_source_dir_2:weight_2,...". The weight + # will be used to sample the data sources. If the sum of the weights is + # not 1 when concatenating the two arguments `data` and `instruct_data`, + # it will be normalized. The data sources folders must contain jsonl files. + # If the value is an empty string, no data will be used for the corresponding + # data type. + data: str = ( + "" # Each line in the jsonl files inside the data source directories must be a dictionary with a "text" key. See Readme for more details. Can be left empty. + ) + shuffle: bool = False + instruct_data: str = ( + "" # Each line in the jsonl files inside the data source directories must be a dictionary with a "interactions" key. See Readme for more details. Can be left empty. + ) + eval_instruct_data: str = ( + "" # Each line in the jsonl files inside the data source directories must be a dictionary with a "interactions" key. See Readme for more details. Can be left empty. + ) + instruct: InstructArgs = field(default_factory=InstructArgs) + + def __post_init__(self) -> None: + if ( + self.instruct.shuffle is False + and self.instruct.dynamic_chunk_fn_call is True + ): + raise ValueError( + "Make sure to either enable `data.instruct.shuffle=True` or `data.instruct.dynamic_chunk_fn_call=False`. Dynamic chunking is only possible if data is loaded and shuffled before training." + ) diff --git a/finetune/data/data_loader.py b/finetune/data/data_loader.py new file mode 100644 index 0000000000000000000000000000000000000000..0c5be855701a47181502cf98dba09e50f19e8c47 --- /dev/null +++ b/finetune/data/data_loader.py @@ -0,0 +1,126 @@ +import dataclasses +from typing import Any, Iterator, List, Optional + +import numpy as np +from mistral_common.tokens.tokenizers.sentencepiece import InstructTokenizerBase + +from .args import DataArgs +from .dataset import build_dataset + + +@dataclasses.dataclass +class Batch: + x: np.ndarray + y: np.ndarray + sizes: List[int] + y_mask: Optional[np.ndarray] = None + is_pad_only: bool = False + + def __post_init__(self): + assert self.x.ndim == 1 + assert self.x.shape == self.y.shape + assert self.x.dtype == np.int64 + assert self.y.dtype == np.int64 + assert isinstance(self.sizes, list) + assert sum(self.sizes) == self.x.size == self.y.size + + if self.y_mask is not None: + assert self.y_mask.size == self.y.size, (self.y_mask.shape, self.y.shape) + assert self.y_mask.dtype == bool + assert sum(self.sizes) == self.y_mask.size + assert not self.y_mask.all() + assert self.y_mask.any() + + if self.is_pad_only: + assert np.sum(np.abs(self.y)) == 0 + assert np.sum(np.abs(self.x)) == 0 + assert self.y_mask is None + # create all 0's mask for pad samples + self.y_mask = np.zeros_like(self.x) + + + + +@dataclasses.dataclass +class BatchList: + x: List[List[int]] = dataclasses.field(default_factory=list) + y: List[List[int]] = dataclasses.field(default_factory=list) + sizes: List[List[int]] = dataclasses.field(default_factory=list) + y_mask: List[Optional[List[int]]] = dataclasses.field(default_factory=list) + + def __post_init__(self): + assert self.x == [], "`BatchList` has to be empty at init." + assert self.y == [], "`BatchList` has to be empty at init." + assert self.sizes == [], "`BatchList` has to be empty at init." + assert self.y_mask == [], "`BatchList` has to be empty at init." + + def __len__(self) -> int: + return len(self.x) + + def add(self, x: List[int], y: List[int], sizes: List[int], y_mask: Optional[List[int]] = None): + self.x.append(x) + self.y.append(y) + self.sizes.append(sizes) + self.y_mask.append(y_mask) + + def empty(self): + self.x = [] + self.y = [] + self.sizes = [] + self.y_mask = [] + + @staticmethod + def flatten_to_numpy(list_of_lists: List[List[Any]], dtype: np.dtype) -> np.array: + return np.array([el for sublist in list_of_lists for el in sublist], dtype=dtype) + + def create_batch(self) -> Batch: + x_np: np.array = self.flatten_to_numpy(self.x, dtype=np.int64) + y_np: np.array = self.flatten_to_numpy(self.y, dtype=np.int64) + sizes = sum(self.sizes, []) # noqa + + y_mask_np: Optional[np.array] = self.flatten_to_numpy(self.y_mask, dtype=bool) + y_mask_np = None if y_mask_np.all() else y_mask_np + + return Batch(x_np, y_np, sizes, y_mask_np) + + + + +def build_data_loader( + instruct_tokenizer: InstructTokenizerBase, + args: DataArgs, + batch_size: int, + seq_len: int, + seed: Optional[int], + rank: int, + world_size: int, + is_eval: bool, +) -> Iterator[Batch]: + pretrain_data = args.data if not is_eval else "" + instruct_data = args.instruct_data if not is_eval else args.eval_instruct_data + + dataset = build_dataset( + pretrain_data=pretrain_data, + instruct_data=instruct_data, + instruct_args=args.instruct, + instruct_tokenizer=instruct_tokenizer, + seq_len=seq_len, + seed=seed, + rank=rank, + world_size=world_size, + is_eval=is_eval, + shuffle_pretrain=args.shuffle, + ) + + batch_list = BatchList() + for sample in dataset: + assert all(s >= 0 for s in sample.sizes) + + batch_list.add(sample.x, sample.y, sample.sizes, sample.mask) + + if len(batch_list) == batch_size: + batch: Batch = batch_list.create_batch() + yield batch + + batch_list.empty() + diff --git a/finetune/data/dataset.py b/finetune/data/dataset.py new file mode 100644 index 0000000000000000000000000000000000000000..516a97ddc2b156b172eb0c763ddc3c9046f39b18 --- /dev/null +++ b/finetune/data/dataset.py @@ -0,0 +1,475 @@ +import dataclasses +import itertools +import json +import logging +from dataclasses import dataclass +from pathlib import Path +from typing import Any, Dict, Iterator, List, Optional, Set, Tuple, Union + +import numpy as np +import torch.distributed as dist +from mistral_common.protocol.instruct.messages import ( + FinetuningAssistantMessage, + SystemMessage, +) +from mistral_common.tokens.tokenizers.sentencepiece import InstructTokenizerBase + +from finetune.distributed import get_rank + +from .args import InstructArgs +from .tokenize import ( + Mask, + SampleType, + TokenSample, + TrainingInstructSample, + build_instruct_sample, + encode, +) + +logger = logging.getLogger("dataset") + + +_LOADED_DATASETS: Dict[Path, List[str]] = {} + + +def main_logger_info(message: str) -> None: + if dist.is_initialized() and get_rank() == 0: + logger.info(message) + + +def load_file(path: Path, world_size: int, rank: int) -> List[str]: + lines = [] + with path.open() as f: + for idx, line in enumerate(f): + if not idx % world_size == rank: + continue + lines.append(line) + return lines + + +def maybe_load_local_dataset( + path: Path, chunk: bool, rank: int, world_size: int, instruct_tokenizer: InstructTokenizerBase, sample_type: SampleType +) -> List[TokenSample]: + global _LOADED_DATASETS + + if path in _LOADED_DATASETS: + return _LOADED_DATASETS[path] + + main_logger_info(f"Loading {path} ...") + lines: List[str] = load_file(path, rank=rank, world_size=world_size) + + if chunk: + lines += maybe_chunk_lines(lines) + + tokens_list: List[TokenSample] = [] + for line in lines: + data = json.loads(line) + + token_sample: TokenSample = encode( + data, + instruct_tokenizer=instruct_tokenizer, + as_type=sample_type, + ) + tokens_list.append(token_sample) + + main_logger_info(f"{path} loaded and tokenized.") + _LOADED_DATASETS[path] = tokens_list + + return _LOADED_DATASETS[path] + + +@dataclass +class DataDir: + path: Path + sample_type: SampleType + + @property + def jsonl_files(self): + assert self.path.exists(), f"Make sure that {self.path} exists" + jsonl_files = list(self.path.rglob("*jsonl")) + assert ( + len(jsonl_files) > 0 + ), f"{self.path} does not seem to have any files ending with '.jsonl'" + return jsonl_files + + +@dataclass +class DataFile: + path: Path + sample_type: SampleType + + @property + def jsonl_files(self): + assert self.path.exists(), f"Make sure that {self.path} exists" + return [self.path] + + +def parse_data_sources( + pretrain_data: str, + instruct_data: str, +) -> Tuple[List[Union[DataDir, DataFile]], List[float]]: + seen: Set[str] = set() + sources: List[Union[DataDir, DataFile]] = [] + weights: List[float] = [] + for sample_sources, sample_type in [ + (pretrain_data, SampleType.PRETRAIN), + (instruct_data, SampleType.INSTRUCT), + ]: + for source in sample_sources.strip().split(","): + if not source: + continue + + source_items = source.strip().split(":") + if len(source_items) == 1: + path_ = source_items[0] + weight = 1.0 + elif len(source_items) == 2: + path_, weight_ = source_items + weight = float(weight_) + else: + raise ValueError( + f"{source} is not correctly formatted. Make sure to format each data source as : or just " + ) + + assert ( + path_ not in seen + ), f"{path_} seems to be duplicated. Make sure to only add it once." + assert ( + weight > 0 + ), f"Make sure to define strictly positive data sampling weights, not {weight}" + + data: Union[DataDir, DataFile] + if Path(path_).is_dir(): + data = DataDir(path=Path(path_), sample_type=sample_type) + elif Path(path_).is_file(): + data = DataFile(path=Path(path_), sample_type=sample_type) + else: + raise FileNotFoundError( + f"The path {path_} does not exist. Make sure {path_} is either a file or directory that contains training data." + ) + + sources.append(data) + weights.append(weight) + + seen.add(path_) + + sum_weights = sum(weights) + n_weights = [weight / sum_weights for weight in weights] + + assert min(n_weights) > 0 + assert ( + abs(1 - sum(n_weights)) < 1e-8 + ), f"Defined data sampling weights {weights} must sum to 1." + return sources, n_weights + + +@dataclasses.dataclass() +class SequenceMaskAndSizes: + """ + Concatenation of samples to reach a given size + """ + + x: List[int] + y: List[int] + mask: Mask + sizes: List[int] + + def __post_init__(self): + assert sum(self.sizes) == len(self.x) == len(self.y) == len(self.mask) + + +def sequence_iterator( + ds_it: Iterator[TokenSample], + seq_len: int, + is_finite: bool, +) -> Iterator[SequenceMaskAndSizes]: + """ + Creates sequences of length `seq_len` from the dataset iterator by concatenating samples. + """ + x_buffer: List[int] = [] + y_buffer: List[int] = [] + mask_buffer: Mask = [] + + sizes: List[int] = [] + n_missing = seq_len + for sample in ds_it: + assert 0 <= len(x_buffer) < seq_len, len(x_buffer) + assert n_missing == seq_len - len( + x_buffer + ), f"n_missing: {n_missing} | seq_len - len(x_buffer) {seq_len - len(x_buffer)}" + + tokens, mask = sample.tokens, sample.masks[1:] + x, y = tokens[:-1], tokens[1:] + cur_pos = 0 + + while cur_pos < len(x): + size = len(x[cur_pos : cur_pos + n_missing]) + + curr_mask = mask[cur_pos : cur_pos + n_missing] + if not any(curr_mask): + cur_pos += size + # we have a sequence with a mask filled with False + continue + + x_buffer.extend(x[cur_pos : cur_pos + n_missing]) + y_buffer.extend(y[cur_pos : cur_pos + n_missing]) + mask_buffer.extend(curr_mask) + n_missing -= size + sizes.append(size) + + cur_pos += size + + if n_missing == 0: + assert len(mask_buffer) == len(x_buffer) == seq_len == len(y_buffer) + assert sum(sizes) == seq_len + # we don't want to yield sequences with a mask filled with False + if any(mask_buffer): + yield SequenceMaskAndSizes( + x=x_buffer, + y=y_buffer, + mask=mask_buffer, + sizes=sizes, + ) + x_buffer, y_buffer = [], [] + mask_buffer = [] + sizes = [] + n_missing = seq_len + + if is_finite: + # if dataloader is in eval, pad to seq length + if any(mask_buffer): + mask_buffer.extend(n_missing * [False]) + x_buffer.extend(n_missing * [0]) + y_buffer.extend(n_missing * [0]) + sizes.append(n_missing) + + yield SequenceMaskAndSizes( + x=x_buffer, + y=y_buffer, + mask=mask_buffer, + sizes=sizes, + ) + + +def build_dataset( + pretrain_data: str, + instruct_data: str, + instruct_args: InstructArgs, + instruct_tokenizer: InstructTokenizerBase, + seq_len: int, + seed: Optional[int], + rank: int, + world_size: int, + is_eval: bool, + shuffle_pretrain: bool = False, +) -> Iterator[SequenceMaskAndSizes]: + sources, probabilities = parse_data_sources( + pretrain_data=pretrain_data, instruct_data=instruct_data + ) + + def do_shuffle(source: Union[DataDir, DataFile]) -> bool: + shuffle = { + SampleType.PRETRAIN: shuffle_pretrain, + SampleType.INSTRUCT: instruct_args.shuffle, + }[source.sample_type] + + return not is_eval and shuffle + + dataset_iterators = [ + get_dataset_iterator( + source, + instruct_args=instruct_args, + instruct_tokenizer=instruct_tokenizer, + rank=rank, + world_size=world_size, + is_finite=is_eval, + seed=seed, + shuffle_at_epoch=do_shuffle(source), + ) + for source in sources + ] + + sequence_iterators = [ + sequence_iterator( + ds_it=it, + seq_len=seq_len, + is_finite=is_eval, + ) + for it in dataset_iterators + ] + + if is_eval: + combined_iterator = itertools.chain.from_iterable(sequence_iterators) + else: + # make sure random_seed is different per rank and original seed + random_seed = np.array((seed, rank)) + rng = np.random.RandomState(seed=random_seed) + combined_iterator = interleave_iterators( + sequence_iterators, probabilities=probabilities, rng=rng + ) + + return combined_iterator + + +def get_rng(seed: int, rank: int) -> np.random.RandomState: + random_seed = np.array((seed, rank)) + rng = np.random.RandomState(seed=random_seed) + return rng + + +def get_dataset_iterator( + source: Union[DataDir, DataFile], + instruct_args: InstructArgs, + instruct_tokenizer: InstructTokenizerBase, + rank: int, + world_size: int, + is_finite: bool, + seed: Optional[int], + shuffle_at_epoch: bool, +) -> Iterator[TokenSample]: + jsonl_files = source.jsonl_files + rng: Optional[np.random.RandomState] = ( + get_rng(seed, rank) if seed is not None else None + ) + + chunk_dataset = ( + instruct_args.dynamic_chunk_fn_call + and source.sample_type == SampleType.INSTRUCT + ) + + if not is_finite: + # train mode + while True: + for jsonl_file in jsonl_files: + if shuffle_at_epoch: + assert rng is not None, "`seed` has to be passed when shuffling" + # will preload all data into RAM, shuffle and yield + yield from preload_and_yield( + jsonl_file, + chunk_dataset=chunk_dataset, + rank=rank, + world_size=world_size, + rng=rng, + instruct_tokenizer=instruct_tokenizer, + sample_type=source.sample_type, + ) + else: + # will read data on-the-fly and yield + main_logger_info(f"Lazily loading {jsonl_file} ...") + yield from lazy_load_and_yield( + jsonl_file, + rank=rank, + world_size=world_size, + instruct_tokenizer=instruct_tokenizer, + sample_type=source.sample_type, + ) + else: + # eval mode + for jsonl_file in jsonl_files: + # No need to shuffle for eval + yield from lazy_load_and_yield( + jsonl_file, + rank=rank, + world_size=world_size, + instruct_tokenizer=instruct_tokenizer, + sample_type=source.sample_type, + ) + + +def preload_and_yield( + jsonl_file: Path, + chunk_dataset: bool, + rank: int, + world_size: int, + rng: np.random.RandomState, + instruct_tokenizer: InstructTokenizerBase, + sample_type: SampleType, +) -> Iterator[TokenSample]: + # only instruct data has to be chunked + # load dataset if not already loaded. Make sure to only load 1/world_size dataset + tokens_list = maybe_load_local_dataset( + jsonl_file, chunk=chunk_dataset, rank=rank, world_size=world_size, instruct_tokenizer=instruct_tokenizer, sample_type=sample_type + ) + + if sample_type == SampleType.PRETRAIN: + assert chunk_dataset is False, "Pretrain data should not have chunking enabled." + + main_logger_info(f"Shuffling {jsonl_file} ...") + rng.shuffle(tokens_list) + + for token_sample in tokens_list: + yield token_sample + +def lazy_load_and_yield( + jsonl_file: Path, + rank: int, + world_size: int, + instruct_tokenizer: InstructTokenizerBase, + sample_type: SampleType, +): + with jsonl_file.open() as file_handle: + for idx, line in enumerate(file_handle): + if not idx % world_size == rank: + continue + + data = json.loads(line) + yield encode( + data, + instruct_tokenizer=instruct_tokenizer, + as_type=sample_type, + ) + + +def maybe_chunk_lines(lines: List[str]) -> List[str]: + extra_lines: List[str] = [] + for line in lines: + data = json.loads(line) + # mult-turn fn call data will be chunked and shorder conversations are added additionally + maybe_chunked_lines = maybe_chunk_data(data) + extra_lines.extend([json.dumps(line) for line in maybe_chunked_lines]) + + return extra_lines + + +def maybe_chunk_data(data: Dict[str, Any]) -> List[Dict[str, Any]]: + # think about always allowing both open-ai and non-open-ai data + sample = build_instruct_sample(data) + + def num_assistant_messages(sample: TrainingInstructSample) -> int: + return len( + [m for m in sample.messages if isinstance(m, FinetuningAssistantMessage)] + ) + + chunk_data = [] + while sample.only_last is True and num_assistant_messages(sample) > 1: + assert sample == build_instruct_sample(sample.dict()) + last_message = sample.messages.pop() + + # 1. First pop until and including last assistant message + system_message = None + while not isinstance(last_message, FinetuningAssistantMessage): + last_message = sample.messages.pop() + if isinstance(last_message, SystemMessage): + system_message = last_message + + # 2. Second pop until and excluding last assistant message + prev_last_message = sample.messages[-1] + while not isinstance(prev_last_message, FinetuningAssistantMessage): + last_message = sample.messages.pop() + if isinstance(last_message, SystemMessage): + system_message = last_message + + prev_last_message = sample.messages[-1] + + # if system_message is not None, append again + if system_message is not None: + sample.messages.append(system_message) + chunk_data.append(sample.dict()) + + return chunk_data + + +def interleave_iterators(iterators: List[Iterator], probabilities, rng): + while True: + it_id = rng.choice(range(len(iterators)), p=probabilities) + yield next(iterators[it_id]) diff --git a/finetune/data/exceptions.py b/finetune/data/exceptions.py new file mode 100644 index 0000000000000000000000000000000000000000..190c07d6871767240e3077fe4c7e580378186e3c --- /dev/null +++ b/finetune/data/exceptions.py @@ -0,0 +1,56 @@ +class MessageFormatError(Exception): + def __init__(self, message, data): + self._message = message + self._begin_data = data[:20] + super().__init__() + + def __str__(self): + return f"A message starting with {self._begin_data} is incorrectly formated." + self._message + + +class ToolCallFormatError(Exception): + def __init__(self, message, data): + self._message = message + self._begin_data = data[:20] + super().__init__() + + def __str__(self): + return f"A tool call assistant message starting with {self._begin_data} of the conversation is incorrectly formated. " + self._message + + +class FunctionFormatError(Exception): + def __init__(self, message, data): + self._message = message + self._begin_data = data[:20] + super().__init__() + + def __str__(self): + return ( + f"A function of the conversation starting with {self._begin_data} is incorrectly formated. " + + self._message + ) + + +class ConversationFormatError(Exception): + def __init__(self, message, data): + self._message = message + self._begin_data = data[:20] + super().__init__() + + def __str__(self): + return ( + f"A conversation starting with {self._begin_data} is incorrectly formated. " + self._message + ) + + +class UnrecognizedRoleError(Exception): + def __init__(self, role, allowed_roles): + self._role = role + self._allowed_roles = allowed_roles + super().__init__() + + def __str__(self): + return ( + f"The following role: {self._role} is not recognized in line: {self.line} of the dataset {self.dataset}. Make sure that each role is one of {self._allowed_roles}" + + self._message + ) diff --git a/finetune/data/tokenize.py b/finetune/data/tokenize.py new file mode 100644 index 0000000000000000000000000000000000000000..ee724fa659f965ac57f8c1c2e65c1b7d0d791693 --- /dev/null +++ b/finetune/data/tokenize.py @@ -0,0 +1,355 @@ +import logging +from dataclasses import dataclass +from enum import Enum +from typing import Any, Dict, List, Optional, Union + +from mistral_common.protocol.instruct.messages import ( + FinetuningAssistantMessage, + Roles, + SystemMessage, + ToolMessage, + UserMessage, +) +from mistral_common.protocol.instruct.tool_calls import ( + Function, + FunctionCall, + Tool, + ToolCall, +) +from mistral_common.protocol.instruct.validator import ( + MistralRequestValidatorV3, + ValidationMode, +) +from mistral_common.tokens.instruct.request import InstructRequest +from mistral_common.tokens.tokenizers.base import Tokenizer +from mistral_common.tokens.tokenizers.sentencepiece import InstructTokenizerBase + +from .exceptions import ( + ConversationFormatError, + FunctionFormatError, + MessageFormatError, + ToolCallFormatError, + UnrecognizedRoleError, +) + +logger = logging.getLogger("tokenize") + +Sequence = List[int] +Mask = List[bool] + + +class TrainingInstructSample(InstructRequest): + available_tools: Optional[List[Tool]] = None + only_last: bool = False + + +@dataclass() +class TokenSample: + tokens: Sequence + masks: Mask + + +class SampleType(str, Enum): + PRETRAIN = "pretrain" + INSTRUCT = "instruct" + + +def encode( + data: Dict[str, Any], + instruct_tokenizer: InstructTokenizerBase, + as_type: SampleType, +) -> TokenSample: + sample: Union[str, TrainingInstructSample] + if as_type == SampleType.PRETRAIN: + sample = get_pretrain_sample(data) + elif as_type == SampleType.INSTRUCT: + sample = build_instruct_sample(data) + + return tokenize(sample=sample, instruct_tokenizer=instruct_tokenizer) + + +def get_pretrain_sample(data: Dict[str, Any]) -> str: + content_keys = ["text", "content"] + assert not all( + k in data for k in content_keys + ), "Make sure to have either 'text' or 'content' in your data. Not both." + assert any( + data.get(k) is not None for k in content_keys + ), f"Must have one of 'text' or 'content' in your data. Only have {data.keys()}" + + # get first non-None value + sample = None + for key in content_keys: + sample = data[key] if key in data else sample + + assert isinstance(sample, str), sample + + return sample + + +def build_instruct_sample(data: Dict[str, Any]) -> TrainingInstructSample: + messages: List[ + SystemMessage | UserMessage | FinetuningAssistantMessage | ToolMessage + ] = [] + # optional data fields that might be set + available_tools: Optional[List[Tool]] = data.get("available_tools") + system_prompt = data.get("system_prompt") + + messages_keys = ["messages", "interactions"] + content_keys = ["content", "text"] # both are accepted + allowed_roles = [role.value for role in Roles] + + if not any(messages_key in data for messages_key in messages_keys): + err = f"The conversation does not contain one of '{', '.join(messages_keys)}' key, but only {', '.join(data.keys())}. Make sure that the conversation includes one of '{', '.join(messages_keys)}'." + raise ConversationFormatError(err, str(data)) + + if all(messages_key in data for messages_key in messages_keys): + err = f"The conversation cannot contain both of '{', '.join(messages_keys)}' key, but only one of the two." + raise ConversationFormatError(err, str(data)) + + # get first non-None value + data_messages: Optional[List[Dict[str, Any]]] = None + for key in messages_keys: + data_messages = data[key] if key in data else data_messages + + assert data_messages is not None, "data_messages can't be None" + + if "available_tools" in data and "tools" in data: + err = "The conversation contains both an `available_tools` and `tools` key. You can only have one." + raise ConversationFormatError(err, str(data)) + + if data.get("tools", None) is not None and len(data["tools"]) > 0: + available_tools = _parse_available_tools(data["tools"]) + elif ( + data.get("available_tools", None) is not None + and len(data["available_tools"]) > 0 + ): + available_tools = _parse_available_tools(data["available_tools"]) + + for data_message in data_messages: + is_tool_call = data_message.get("tool_calls") is not None + + if "role" not in data_message: + err = f"A message does not contain a 'role' key, but only {', '.join(data_message.keys())}. Make sure that the message includes the key 'role'." + raise MessageFormatError(err, str(data)) + + role = data_message["role"] + + if all(key in data_message for key in content_keys): + err = f"A {role} message contains both a 'text' and 'content' key. Make sure that there is only one of the two." + raise MessageFormatError(err, str(data)) + + content: Optional[str] = None + for key in content_keys: + content = content if content is not None else data_message.get(key) + + # non-function call message must have content + if not is_tool_call and content is None: + err = f"A {role} message does not contain one of '{content_keys}' key, but only {', '.join(data_message.keys())}. Make sure that the message includes one of '{content_keys}' keys." + raise MessageFormatError(err, str(data)) + + if role not in allowed_roles: + raise UnrecognizedRoleError(role, allowed_roles) + + if data_message["role"] == "user": + assert content is not None + messages.append(UserMessage(content=content)) + elif data_message["role"] == "assistant": + tool_calls: Optional[List[ToolCall]] = None + + if is_tool_call: + tool_calls = _parse_tool_calls(data_message["tool_calls"]) + + weight = data_message.get("weight") + messages.append( + FinetuningAssistantMessage( + content=content, tool_calls=tool_calls, weight=weight + ) + ) + elif data_message["role"] == "system": + if system_prompt is not None: + err = "Multiple messages with role 'system' encountered. Only one is allowed." + raise MessageFormatError(err, str(data)) + + system_prompt = content + elif data_message["role"] == "tool": + assert content is not None + tool_message = _parse_tool_message(content, data_message) + messages.append(tool_message) + + # validate created messages + validator = MistralRequestValidatorV3(ValidationMode.finetuning) + validator.validate_messages(messages) + validator._validate_tools(available_tools or []) + + # whether to train only on last assistant message + only_last = data.get("only_last", False) or available_tools is not None + + return TrainingInstructSample( + messages=messages, + system_prompt=system_prompt, + available_tools=available_tools, + only_last=only_last, + ) + + +def _parse_available_tools(tools: List[Dict[str, Any]]) -> List[Tool]: + available_tools = [] + for tool in tools: + if "function" not in tool: + raise FunctionFormatError( + "A tool dict does not have a 'function' key.", str(tool) + ) + + func_data = tool["function"] + + for key in ["name", "description", "parameters"]: + if key not in func_data: + raise FunctionFormatError( + f"A function dict does not have a {key} key.", str(func_data) + ) + + if not isinstance(func_data["parameters"], dict): + raise FunctionFormatError( + f"A function 'parameters' key has to be of type dict, but is {type(func_data['parameters'])}. If the function has no parameters pass an empyt dict ", str(func_data) + ) + + description = func_data["description"] + function = Function( + name=func_data["name"], + description=description, + parameters=func_data["parameters"], + ) + + available_tools.append(Tool(function=function)) + return available_tools + + +def _parse_tool_calls(calls: List[Dict[str, Any]]) -> List[ToolCall]: + for key in ["id", "function"]: + if not all(key in call for call in calls): + err = f"A tool call of an assistant message does not have a {key} key" + raise ToolCallFormatError(err, str(calls)) + + for key in ["name", "arguments"]: + if not all(key in call["function"] for call in calls): + err = ( + f"A tool call function of an assistant message does not have a {key} key" + ) + raise ToolCallFormatError(err, str(calls)) + + if not all(isinstance(call["function"]["arguments"], str) for call in calls): + err = "A tool call function of an assistant message does not have a 'arguments' key of type str" + raise ToolCallFormatError(err, str(calls)) + + tool_calls = [ + ToolCall( + id=call["id"], + function=FunctionCall( + name=call["function"]["name"], + arguments=call["function"]["arguments"], + ), + ) + for call in calls + ] + return tool_calls + + +def _parse_tool_message(content: str, data_message: Dict[str, Any]) -> ToolMessage: + if "tool_call_id" not in data_message: + err = f"A tool message does not contain a 'tool_call_id' key, but only {', '.join(data_message.keys())}. Make sure that the message includes the key 'tool_call_id'." + raise MessageFormatError(err, str(data_message)) + + call_id = data_message["tool_call_id"] + # name is deprecated in v3, but we'll add it nevertheless for now + name = data_message.get("name") + + return ToolMessage(content=content, tool_call_id=call_id, name=name) + + +def tokenize( + sample: Union[str, TrainingInstructSample], + instruct_tokenizer: InstructTokenizerBase, +) -> TokenSample: + if isinstance(sample, str): + tokenizer: Tokenizer = instruct_tokenizer.tokenizer + return tokenize_pretrain(sample, tokenizer) + elif isinstance(sample, TrainingInstructSample): + return tokenize_instruct(sample, instruct_tokenizer) + + raise ValueError( + f"`sample` has to be either of type `str` or `TrainingInstructSample`, not {type(sample)}." + ) + + +def tokenize_pretrain(sample: str, tokenizer: Tokenizer) -> TokenSample: + tokens = tokenizer.encode(sample, bos=True, eos=True) + masks = [True] * len(tokens) + return TokenSample(tokens, masks) + + +def tokenize_instruct( + sample: TrainingInstructSample, + instruct_tokenizer: InstructTokenizerBase, +) -> TokenSample: + tokens: List[int] = instruct_tokenizer.start() + masks: List[bool] = [False] + + mask_all_but_last = sample.only_last + + # find first and last user message + user_messages = [ + i for i, msg in enumerate(sample.messages) if isinstance(msg, UserMessage) + ] + first_user_idx = user_messages[0] if user_messages else -1 + last_user_idx = user_messages[-1] if user_messages else -1 + + for msg_idx, message in enumerate(sample.messages): + if isinstance(message, UserMessage): + curr_tokens = instruct_tokenizer.encode_user_message( + message, + available_tools=sample.available_tools, + is_last=msg_idx == last_user_idx, + is_first=msg_idx == first_user_idx, + system_prompt=sample.system_prompt, + ) + curr_masks = [False] * len(curr_tokens) # only predict bot answers + elif isinstance(message, ToolMessage): + curr_tokens = instruct_tokenizer.encode_tool_message( + message, is_before_last_user_message=msg_idx < last_user_idx + ) + curr_masks = [False] * len(curr_tokens) # only predict bot answers + elif isinstance(message, FinetuningAssistantMessage): + is_last_message = msg_idx == (len(sample.messages) - 1) + + # we don't want to predict a random call id + message = maybe_remove_call_id(message, is_last_message=is_last_message) + + curr_tokens = instruct_tokenizer.encode_assistant_message( + message, is_before_last_user_message=False + ) + + is_weighted = message.weight is None or message.weight == 1 + is_relevant = (not mask_all_but_last) or is_last_message + if is_weighted and is_relevant: + curr_masks = [True] * len(curr_tokens) # only predict bot answers + else: + # in function calling we only backprop through last message + curr_masks = [False] * len(curr_tokens) + + tokens.extend(curr_tokens) + masks.extend(curr_masks) + + return TokenSample(tokens, masks) + + +def maybe_remove_call_id(message: FinetuningAssistantMessage, is_last_message: bool): + if message.tool_calls is None or not is_last_message: + return message + + # remove call id + message.tool_calls = [ + ToolCall(function=call.function) for call in message.tool_calls + ] + + return message diff --git a/finetune/distributed.py b/finetune/distributed.py new file mode 100644 index 0000000000000000000000000000000000000000..5e9d2deac10a3f7492a9398e600b25681b23f3d6 --- /dev/null +++ b/finetune/distributed.py @@ -0,0 +1,59 @@ +import logging +import os +from functools import lru_cache +from typing import List, Union + +import torch +import torch.distributed as dist + +logger = logging.getLogger("distributed") + +BACKEND = "nccl" + + +@lru_cache() +def get_rank() -> int: + return dist.get_rank() + + +@lru_cache() +def get_world_size() -> int: + return dist.get_world_size() + + +def visible_devices() -> List[int]: + return [int(d) for d in os.environ["CUDA_VISIBLE_DEVICES"].split(",")] + + +def set_device(): + logger.info(f"torch.cuda.device_count: {torch.cuda.device_count()}") + logger.info(f"CUDA_VISIBLE_DEVICES: {os.environ['CUDA_VISIBLE_DEVICES']}") + logger.info(f"local rank: {int(os.environ['LOCAL_RANK'])}") + + assert torch.cuda.is_available() + + assert len(visible_devices()) == torch.cuda.device_count() + + if torch.cuda.device_count() == 1: + # gpus-per-task set to 1 + torch.cuda.set_device(0) + return + + local_rank = int(os.environ["LOCAL_RANK"]) + logger.info(f"Set cuda device to {local_rank}") + + assert 0 <= local_rank < torch.cuda.device_count(), ( + local_rank, + torch.cuda.device_count(), + ) + torch.cuda.set_device(local_rank) + + +def avg_aggregate(metric: Union[float, int]) -> Union[float, int]: + buffer = torch.tensor([metric], dtype=torch.float32, device="cuda") + dist.all_reduce(buffer, op=dist.ReduceOp.SUM) + return buffer[0].item() / get_world_size() + + +def is_torchrun() -> bool: + return "TORCHELASTIC_RESTART_COUNT" in os.environ diff --git a/finetune/eval.py b/finetune/eval.py new file mode 100644 index 0000000000000000000000000000000000000000..61ced413de1b5f49e9dc50db7095a78a710cbb6e --- /dev/null +++ b/finetune/eval.py @@ -0,0 +1,77 @@ +import logging +from typing import List + +import numpy as np +import torch.cuda +import torch.distributed as dist +from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel + +from .data.data_loader import Batch +from .distributed import get_rank, get_world_size +from .loss import compute_loss_with_mask +from .utils import TrainState + +logger = logging.getLogger("eval") + + +def main_logger_info(message: str) -> None: + if get_rank() == 0: + logger.info(message) + + +def evaluate( + model: FullyShardedDataParallel, + batches: List[Batch], + state: TrainState, +): + # Create fake samples to make FSDP happy for unbalanced data + num_samples = torch.tensor([len(batches)], device="cuda", dtype=torch.long) + all_num_samples = [torch.zeros_like(num_samples) for _ in range(get_world_size())] + + torch.distributed.all_gather(all_num_samples, num_samples) + + total_num_samples = int(torch.tensor(all_num_samples).sum().item()) + max_num_samples = int(torch.tensor(all_num_samples).max().item()) + + for _ in range(max_num_samples - int(num_samples.item())): + pad_x = np.zeros_like(batches[-1].x) + pad_y = np.zeros_like(batches[-1].y) + pad_sizes = batches[-1].sizes.copy() + + pad_batch = Batch(pad_x, pad_y, pad_sizes, is_pad_only=True) + batches.append(pad_batch) + + # eval mode! + model.eval() + + eval_loss = torch.tensor(0.0).cuda() + main_logger_info("Start eval...") + for batch in batches: + x = torch.from_numpy(batch.x).cuda() + y = torch.from_numpy(batch.y).cuda() + y_mask = ( + torch.from_numpy(batch.y_mask).cuda() if batch.y_mask is not None else None + ) + + with torch.no_grad(): + output = model( + input_ids=x, + seqlens=batch.sizes, + ) + + if y_mask.sum() > 0: + eval_loss += compute_loss_with_mask(output, y, y_mask) + + assert batch.is_pad_only or y.abs().sum() != 0, "Pad sample is used to compute loss." + + # sum loss + main_logger_info("Eval finished!") + + dist.all_reduce(eval_loss, op=dist.ReduceOp.SUM) + eval_loss /= total_num_samples + + state.this_eval_loss = eval_loss.item() + state.this_eval_perplexity = (2**eval_loss).item() + + # train mode! + model.train() diff --git a/finetune/loss.py b/finetune/loss.py new file mode 100644 index 0000000000000000000000000000000000000000..d5c69b8fc3c59a6ebcbfa57e9aaf4bcb73664bf2 --- /dev/null +++ b/finetune/loss.py @@ -0,0 +1,16 @@ +from typing import Optional + +import torch +from torch.nn import functional as F + + +def compute_loss_with_mask( + logits: torch.Tensor, target: torch.Tensor, target_mask: Optional[torch.Tensor] +): + if target_mask is None: + return F.cross_entropy(logits, target, reduction="mean") + + mb_loss = F.cross_entropy(logits, target, reduction="none") + mb_loss = torch.sum(mb_loss * target_mask) / torch.sum(target_mask) + + return mb_loss diff --git a/finetune/mixed_precision.py b/finetune/mixed_precision.py new file mode 100644 index 0000000000000000000000000000000000000000..d017325ff7047611dce90c70ed6a21bbf5b0b91f --- /dev/null +++ b/finetune/mixed_precision.py @@ -0,0 +1,47 @@ +from typing import Iterable + +import torch + + +def prepare_mixed_precision( + params: Iterable[torch.nn.Parameter], + param_dtype: torch.dtype, + optim_dtype: torch.dtype, +): + """Appends a freshly allocated fp32 tensor copy of all params to parameters that can be updated.""" + with torch.no_grad(): + for p in params: + if p.requires_grad: + # Mixed precision: let's save a fp32 param tensor to each params that require a grad + p._mp_param = torch.empty_like(p, dtype=optim_dtype) # type: ignore + p._mp_param.copy_(p.to(optim_dtype)) # type: ignore + + p.data = p.data.to(param_dtype) + + +def upcast_mixed_precision( + params: Iterable[torch.nn.Parameter], optim_dtype: torch.dtype +): + """Make sure to run this function BEFORE optimizer.step() so that all weights and optimizer states are updated in fp32 in .step()""" + with torch.no_grad(): + for p in params: + if p.requires_grad and p.grad is not None: + # store original tensor in p._temp + p._temp = p.data # type: ignore + # upcast data for the optimizer step + p.data = p._mp_param # type: ignore + p.grad = p.grad.to(optim_dtype) + + +def downcast_mixed_precision( + params: Iterable[torch.nn.Parameter], param_dtype: torch.dtype +): + """Make sure to run this function AFTER optimizer.step() as optimizer.step() will update data underlying p.data and p._mp_param pointers""" + with torch.no_grad(): + for p in params: + if p.requires_grad and p.grad is not None: + # copy fp32 weights into bfloat16 tensor + p._temp.copy_(p.data) # type: ignore + # set _temp again to the data tensor + p.data = p._temp # type: ignore + p.grad = p.grad.to(param_dtype) diff --git a/finetune/monitoring/__init__.py b/finetune/monitoring/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/finetune/monitoring/__pycache__/__init__.cpython-310.pyc b/finetune/monitoring/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..2be7593310772afcccf0a24f3ad1a32ffe8acd9a Binary files /dev/null and b/finetune/monitoring/__pycache__/__init__.cpython-310.pyc differ diff --git a/finetune/monitoring/__pycache__/metrics_logger.cpython-310.pyc b/finetune/monitoring/__pycache__/metrics_logger.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5910219c1134ca6a9fcefaf71f0f9708ac06b0a9 Binary files /dev/null and b/finetune/monitoring/__pycache__/metrics_logger.cpython-310.pyc differ diff --git a/finetune/monitoring/__pycache__/utils.cpython-310.pyc b/finetune/monitoring/__pycache__/utils.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..cf208642900da38f0511b5296a020af3da4d50e6 Binary files /dev/null and b/finetune/monitoring/__pycache__/utils.cpython-310.pyc differ diff --git a/finetune/monitoring/metrics_logger.py b/finetune/monitoring/metrics_logger.py new file mode 100644 index 0000000000000000000000000000000000000000..4fdf2ffe6707cc80b7eb183a5804e9c5daa0fd41 --- /dev/null +++ b/finetune/monitoring/metrics_logger.py @@ -0,0 +1,226 @@ +import json +import logging +import os +from datetime import datetime, timedelta +from pathlib import Path +from typing import Any, Dict, Optional, Union + +from torch.utils.tensorboard import SummaryWriter + +from finetune.args import MLFlowArgs, TrainArgs, WandbArgs +from finetune.utils import TrainState + +logger = logging.getLogger("metrics_logger") + +GB = 1024**3 + + +def get_train_logs( + state: TrainState, + loss: float, + lr: float, + peak_allocated_mem: float, + allocated_mem: float, + train_args: TrainArgs, +) -> Dict[str, Union[float, int]]: + metrics = { + "lr": lr, + "step": state.step, + "loss": loss, + "percent_done": 100 * state.step / train_args.max_steps, + "peak_allocated_mem": peak_allocated_mem / GB, + "allocated_mem": allocated_mem / GB, + "wps": state.wps, + "avg_wps": state.avg_wps, + "eta_in_seconds": state.eta, + } + + return metrics + + +def get_eval_logs( + step: int, + train_loss: float, + perplexity: Optional[float], + eval_loss: Optional[float], +) -> Dict[str, Union[float, int]]: + eval_dict = {"step": step, "train_loss": train_loss} + + if perplexity is not None: + eval_dict["perplexity"] = perplexity + + if eval_loss is not None: + eval_dict["eval_loss"] = eval_loss + return eval_dict + + +def train_log_msg( + state: TrainState, logs: Dict[str, Union[float, int]], loss: float +) -> str: + metrics: Dict[str, Union[float, int, datetime]] = dict(logs) # shallow copy + metrics.pop("eta_in_seconds") + + metrics["eta"] = datetime.now() + timedelta(seconds=state.eta) + metrics["step"] = state.step + metrics["loss"] = loss + + parts = [] + for key, fmt, new_name in [ + ("step", "06", None), + ("percent_done", "03.1f", "done (%)"), + ("loss", ".3f", None), + ("lr", ".1e", None), + ("peak_allocated_mem", ".1f", "peak_alloc_mem (GB)"), + ("allocated_mem", ".1f", "alloc_mem (GB)"), + ("wps", ".1f", "words_per_second"), + ("avg_wps", ".1f", "avg_words_per_second"), + ("eta", "%Y-%m-%d %H:%M:%S", "ETA"), + ]: + name = key if new_name is None else new_name + try: + parts.append(f"{name}: {metrics[key]:>{fmt}}") + except KeyError: + logger.error(f"{key} not found in {sorted(metrics.keys())}") + raise + + return " - ".join(parts) + + +def eval_log_msg(logs: Dict[str, Union[float, int]]) -> str: + parts = [] + for key, fmt, new_name in [ + ("step", "06", None), + ("perplexity", ".3f", "eval_perplexity"), + ("eval_loss", ".3f", None), + ("train_loss", ".3f", None), + ]: + name = key if new_name is None else new_name + if key in logs: + parts.append(f"{name}: {logs[key]:>{fmt}}") + + return " - ".join(parts) + + +class MetricsLogger: + def __init__( + self, + dst_dir: Path, + tag: str, + is_master: bool, + wandb_args: WandbArgs, + mlflow_args: MLFlowArgs, + config: Optional[Dict[str, Any]] = None, + ): + self.dst_dir = dst_dir + self.tag = tag + self.is_master = is_master + self.jsonl_path = dst_dir / f"metrics.{tag}.jsonl" + self.tb_dir = dst_dir / "tb" + self.summary_writer: Optional[SummaryWriter] = None + + if not self.is_master: + return + + filename_suffix = f".{tag}" + self.tb_dir.mkdir(exist_ok=True) + self.summary_writer = SummaryWriter( + log_dir=str(self.tb_dir), + max_queue=1000, + filename_suffix=filename_suffix, + ) + self.is_wandb = wandb_args.project is not None + self.is_mlflow = mlflow_args.tracking_uri is not None + + if self.is_wandb: + import wandb + + if wandb_args.key is not None: + wandb.login(key=wandb_args.key) # LLM + if wandb_args.offline: + os.environ["WANDB_MODE"] = "offline" + if wandb.run is None: + logger.info("initializing wandb") + wandb.init( + config=config, + dir=dst_dir, + project=wandb_args.project, + job_type="training", + name=wandb_args.run_name or dst_dir.name, + resume=False, + ) + + self.wandb_log = wandb.log + + if self.is_mlflow: + import mlflow + + mlflow.set_tracking_uri(mlflow_args.tracking_uri) + mlflow.set_experiment(mlflow_args.experiment_name or dst_dir.name) + + if tag == "train": + mlflow.start_run() + + self.mlflow_log = mlflow.log_metric + + def log(self, metrics: Dict[str, Union[float, int]], step: int): + if not self.is_master: + return + + metrics_to_ignore = {"step"} + assert self.summary_writer is not None + for key, value in metrics.items(): + if key in metrics_to_ignore: + continue + assert isinstance(value, (int, float)), (key, value) + self.summary_writer.add_scalar( + tag=f"{self.tag}.{key}", scalar_value=value, global_step=step + ) + + if self.is_mlflow: + self.mlflow_log(f"{self.tag}.{key}", value, step=step) + + if self.is_wandb: + # grouping in wandb is done with / + self.wandb_log( + { + f"{self.tag}/{key}": value + for key, value in metrics.items() + if key not in metrics_to_ignore + }, + step=step, + ) + + metrics_: Dict[str, Any] = dict(metrics) # shallow copy + if "step" in metrics_: + assert step == metrics_["step"] + else: + metrics_["step"] = step + metrics_["at"] = datetime.utcnow().isoformat() + with self.jsonl_path.open("a") as fp: + fp.write(f"{json.dumps(metrics_)}\n") + + def close(self): + if not self.is_master: + return + + if self.summary_writer is not None: + self.summary_writer.close() + self.summary_writer = None + + if self.is_wandb: + import wandb + + # to be sure we are not hanging while finishing + wandb.finish() + + if self.is_mlflow: + import mlflow + + mlflow.end_run() + + def __del__(self): + if self.summary_writer is not None: + raise RuntimeError( + "MetricsLogger not closed properly! You should " + "make sure the close() method is called!" + ) diff --git a/finetune/monitoring/utils.py b/finetune/monitoring/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..48161a88cafc4f9e8e13fb18858d9cde8bcce71b --- /dev/null +++ b/finetune/monitoring/utils.py @@ -0,0 +1,34 @@ +import datetime +import logging +import sys +import time + + +class DeltaTimeFormatter(logging.Formatter): + def format(self, record): + delta = datetime.timedelta( + seconds=int(record.relativeCreated / 1000) + ) # no milliseconds + record.delta = delta + return super().format(record) + + +def set_logger(level: int = logging.INFO): + root = logging.getLogger() + root.handlers.clear() + root.setLevel(level) + tz, *_ = time.tzname + + LOGFORMAT = "%(asctime)s - %(delta)s - %(name)s - %(levelname)s - %(message)s" + TIMEFORMAT = f"%Y-%m-%d %H:%M:%S ({tz})" + formatter = DeltaTimeFormatter(LOGFORMAT, TIMEFORMAT) + + handler = logging.StreamHandler(sys.stdout) + handler.setLevel(level) + handler.setFormatter(formatter) + root.addHandler(handler) + + handler = logging.StreamHandler(sys.stderr) + handler.setLevel(logging.WARNING) + handler.setFormatter(formatter) + root.addHandler(handler) diff --git a/finetune/utils.py b/finetune/utils.py new file mode 100644 index 0000000000000000000000000000000000000000..95119a70b40f83292287b1197102c31fd244dc96 --- /dev/null +++ b/finetune/utils.py @@ -0,0 +1,83 @@ +import contextlib +import dataclasses +import datetime +import logging +import time +from typing import Optional, Protocol + +import torch + +logger = logging.getLogger("utils") + + +@dataclasses.dataclass +class TrainState: + max_steps: int + step: int = 0 + elapsed_time: float = 0.0 + n_seen_tokens: int = 0 + this_step_time: float = 0.0 + begin_step_time: float = 0.0 + this_eval_perplexity: Optional[float] = None + this_eval_loss: Optional[float] = None + + def start_step(self): + self.step += 1 + self.begin_step_time = time.time() + + def end_step(self, n_batch_tokens: int): + self.this_step_time = time.time() - self.begin_step_time + self.this_step_tokens = n_batch_tokens + + self.elapsed_time += self.this_step_time + self.n_seen_tokens += self.this_step_tokens + + self.begin_step_time = time.time() + + @property + def wps(self): + return self.this_step_tokens / self.this_step_time + + @property + def avg_wps(self): + return self.n_seen_tokens / self.elapsed_time + + @property + def eta(self): + steps_left = self.max_steps - self.step + avg_time_per_step = self.elapsed_time / self.step + + return steps_left * avg_time_per_step + + +def set_random_seed(seed: int) -> None: + """Set random seed for reproducibility.""" + torch.manual_seed(seed) + torch.cuda.manual_seed(seed) + + +class Closable(Protocol): + def close(self): + pass + + +@contextlib.contextmanager +def logged_closing(thing: Closable, name: str): + """ + Logging the closing to be sure something is not hanging at exit time + """ + try: + setattr(thing, "wrapped_by_closing", True) + yield + finally: + logger.info(f"Closing: {name}") + try: + thing.close() + except Exception: + logger.error(f"Error while closing {name}!") + raise + logger.info(f"Closed: {name}") + + +def now_as_str() -> str: + return datetime.datetime.now().strftime("%Y-%m-%d_%H-%M-%S") diff --git a/finetune/wrapped_model.py b/finetune/wrapped_model.py new file mode 100644 index 0000000000000000000000000000000000000000..6034b4c68cf6ea52cb91be42c83f0cb2eb43280f --- /dev/null +++ b/finetune/wrapped_model.py @@ -0,0 +1,227 @@ +import functools +import json +import logging +import math +from pathlib import Path +from typing import Callable, Union + +import safetensors +import torch +import torch.distributed.fsdp.wrap as torch_wrap +from torch.distributed.fsdp import BackwardPrefetch +from torch.distributed.fsdp.api import ShardingStrategy +from torch.distributed.fsdp.fully_sharded_data_parallel import FullyShardedDataParallel + +from model.args import ModelArgs, MoeArgs +from model.transformer import Transformer, TransformerBlock + +from .args import LoraArgs +from .checkpointing import Checkpointer +from .distributed import ( + get_rank, + get_world_size, +) + +logger = logging.getLogger(__name__) + + +def main_logger_info(message: str) -> None: + if get_rank() == 0: + logger.info(message) + + +def get_fsdp_policy(is_lora: bool) -> Callable[[torch.nn.Module], bool]: + """ + This function instantiates the FSDP wrap policy. + - Each Transformers block becomes it's own FSDP group so that only a single Transformer block is sharded at a time + - If LoRA is enabled, we additionally create seperate FSDP sub-groups for every trainable and non-trainable parameter group + since this is a requirement for mixed requires_grad=True/False training. See: https://pytorch.org/docs/stable/fsdp.html + """ + + # Each transformer block becomes a FSDP group, each being sharded seperately + transformer_block_wrap_policy = functools.partial( + torch_wrap.transformer_auto_wrap_policy, + transformer_layer_cls=(TransformerBlock,), + ) + + if not is_lora: + return transformer_block_wrap_policy + + def fsdp_lora_policy_fn(module): + return all(p.requires_grad for p in module.parameters()) + + # For LoRA training, trainable and non-trainable parameters need to be put into + # different FSDP groups + fsdp_lora_policy = functools.partial( + torch_wrap.lambda_auto_wrap_policy, lambda_fn=fsdp_lora_policy_fn + ) + + policies = [fsdp_lora_policy, transformer_block_wrap_policy] + + return functools.partial(torch_wrap._or_policy, policies=policies) + + +def log_train_params(model: Union[torch.nn.Module, FullyShardedDataParallel]): + world_size = get_world_size() + + num_params = world_size * sum(p.numel() for p in model.parameters()) + num_train_params = world_size * sum( + p.numel() for p in model.parameters() if p.requires_grad + ) + + main_logger_info( + f"{num_train_params:,.0f} out of {num_params:,.0f} parameter are finetuned ({num_train_params / num_params * 100:.2f}%)." + ) + + +def initialize_lora_parameters(model: torch.nn.Module, param_dtype: torch.dtype): + """ + Initialize LoRA layers with Kaiming uniform and zeros. + See original paper for more info: https://arxiv.org/abs/2106.09685 and + original github repo: https://github.com/microsoft/LoRA/blob/a0a92e0f26c067cf94747bdbf1ce73793fa44d19/loralib/layers.py#L122 + """ + for m_name, module in model.named_modules(): + if all(p.is_meta for p in module.parameters()): + for p_name, param in module.named_parameters(): + module._parameters[p_name] = torch.nn.Parameter( + torch.empty_like(param, device="cpu", dtype=param_dtype) + ) + param = module._parameters[p_name] + + if m_name.split(".")[-1] == "lora_A": + torch.nn.init.kaiming_uniform_(param, a=math.sqrt(5)) + elif m_name.split(".")[-1] == "lora_B": + torch.nn.init.zeros_(param) + else: + raise ValueError( + "Only Lora layers should be randomely initialized." + ) + + +def load_model( + folder: Path, + lora: LoraArgs, + checkpoint: bool, + param_dtype: torch.dtype, +) -> FullyShardedDataParallel: + with open(folder / "params.json", "r") as f: + args = json.loads(f.read()) + + model_args = ModelArgs( + lora=lora, + dim=args["dim"], + n_layers=args["n_layers"], + head_dim=args["head_dim"], + hidden_dim=args["hidden_dim"], + n_heads=args["n_heads"], + n_kv_heads=args["n_kv_heads"], + norm_eps=args["norm_eps"], + vocab_size=args["vocab_size"], + ) + + if model_args.vocab_size == 32000: + raise ValueError( + f"Fine-tuning is not supported for older model versions with vocab_size 32000. Make sure to extend your model to vocab_size=32768 using `python -m utils.extend_model_vocab --original_model_ckpt {folder} --extended_model_ckpt {folder}_extended`." + ) + + assert ( + model_args.vocab_size >= 32768 + ), "Make sure to use a model with a vocab size of at least 32768" + + if args.get("rope_theta") is not None: + model_args.rope_theta = args["rope_theta"] + + if args.get("moe") is not None: + model_args.moe = MoeArgs(**args["moe"]) + + with torch.device("meta"): + model = Transformer(args=model_args, checkpoint=checkpoint) + + if get_rank() == 0: + state_dict = load_state_dict(folder, dtype=param_dtype) + + model.load_state_dict(state_dict, assign=True) # type: ignore + logger.info("Loaded model on cpu!") + + if lora.enable: + logger.info("Initializing lora layers ...") + # initialize LoRA layers + initialize_lora_parameters(model, param_dtype) + + assert not any( + p.is_meta for p in model.parameters() + ), "All parameters should be intialized by now" + assert all( + p.dtype == param_dtype for p in model.parameters() + ), f"All parameters should be on {param_dtype}" + + logger.info("Finished initialization!") + param_init_fn = None + else: + + def param_init_fn(m): + m.to_empty(device=torch.cuda.current_device(), recurse=False) + m.to(param_dtype) + + assert all( + p.is_meta for p in model.parameters() + ), "All parameters should be on meta" + + torch.distributed.barrier() + + # only finetune LoRA parameters and freeze before wrapping + if lora.enable: + for name, param in model.named_parameters(): + if "lora" in name: + param.requires_grad = True + else: + param.requires_grad = False + + auto_wrap_policy = get_fsdp_policy(model_args.lora.enable) + + main_logger_info(f"Sharding model over {get_world_size()} GPUs ...") + + wrapped_model = FullyShardedDataParallel( + model, + sharding_strategy=ShardingStrategy.FULL_SHARD, + auto_wrap_policy=auto_wrap_policy, + backward_prefetch=BackwardPrefetch.BACKWARD_PRE, + limit_all_gathers=True, + device_id=torch.cuda.current_device(), + sync_module_states=True, + param_init_fn=param_init_fn, + ) + main_logger_info("Model sharded!") + + log_train_params(wrapped_model) + + return wrapped_model + + +@torch.no_grad() +def load_state_dict(path: Path, dtype: torch.dtype): + assert path.is_dir(), path + + this_safetensors_path = Checkpointer.consolidated_path(path, use_safetensors=True) + this_torch_path = Checkpointer.consolidated_path(path, use_safetensors=False) + + assert ( + this_safetensors_path.exists() or this_torch_path.exists() + ), f"Either {this_safetensors_path} or {this_torch_path} must exist." + assert not ( + this_safetensors_path.exists() and this_torch_path.exists() + ), f"Only one of {this_safetensors_path} or {this_torch_path} should exist." + + if this_safetensors_path.exists(): + logger.info(f"Reloading model from {this_safetensors_path} ...") + model_state_dict = safetensors.torch.load_file(this_safetensors_path) + else: + logger.info(f"Reloading model from {this_torch_path} ...") + model_state_dict = torch.load(this_torch_path) + + logger.info(f"Converting model to dtype {dtype} ...") + + for k, v in model_state_dict.items(): + model_state_dict[k] = v.to(dtype) + + return model_state_dict diff --git a/huggingface.ipynb b/huggingface.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..b816d7c56e82554c93503db5e5c53944fc6d13b8 --- /dev/null +++ b/huggingface.ipynb @@ -0,0 +1,40 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [ + "from huggingface_hub import HfApi, HfFolder, Repository\n", + "\n", + "repo_id = \"your_username/your_model_name\"\n", + "repo_local_path = \"./path_to_your_model\"\n", + "\n", + "# Create the repository object and clone the repo\n", + "repo = Repository(local_dir=repo_local_path, clone_from=repo_id)\n", + "\n", + "# Copy your model files to the repository\n", + "model_files = [\"config.json\", \"pytorch_model.bin\", \"tokenizer_config.json\", \"vocab.json\"]\n", + "for file in model_files:\n", + " shutil.copy(file, repo_local_path)\n", + "\n", + "# Push the model files to the repository\n", + "repo.push_to_hub(commit_message=\"Initial model upload\")\n" + ] + } + ], + "metadata": { + "kernelspec": { + "display_name": "chemistralpy310", + "language": "python", + "name": "python3" + }, + "language_info": { + "name": "python", + "version": "3.10.14" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/model/__init__.py b/model/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/model/__pycache__/__init__.cpython-310.pyc b/model/__pycache__/__init__.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..15790cbc52823b76f46feee5d34d6364cb837ca2 Binary files /dev/null and b/model/__pycache__/__init__.cpython-310.pyc differ diff --git a/model/__pycache__/__init__.cpython-38.pyc b/model/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..09322f4e66701fab4a1c928ecd65235143f0feb2 Binary files /dev/null and b/model/__pycache__/__init__.cpython-38.pyc differ diff --git a/model/__pycache__/args.cpython-310.pyc b/model/__pycache__/args.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..a0b019154be0fe679e26d0c7b991e8d86d5ce6db Binary files /dev/null and b/model/__pycache__/args.cpython-310.pyc differ diff --git a/model/__pycache__/args.cpython-38.pyc b/model/__pycache__/args.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..c892b0e26cf9a7d832b0aa38ff45e064e88f51c5 Binary files /dev/null and b/model/__pycache__/args.cpython-38.pyc differ diff --git a/model/__pycache__/lora.cpython-310.pyc b/model/__pycache__/lora.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..d4897c5c176a5f218ab7388d9a9d7f67e02ddccc Binary files /dev/null and b/model/__pycache__/lora.cpython-310.pyc differ diff --git a/model/__pycache__/lora.cpython-38.pyc b/model/__pycache__/lora.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..3531be46f50c5e7b2f14a3ee069253a493b8978c Binary files /dev/null and b/model/__pycache__/lora.cpython-38.pyc differ diff --git a/model/__pycache__/moe.cpython-310.pyc b/model/__pycache__/moe.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..5e3f2aa19121d7af8cfe596d7bb47dba0a858f4d Binary files /dev/null and b/model/__pycache__/moe.cpython-310.pyc differ diff --git a/model/__pycache__/moe.cpython-38.pyc b/model/__pycache__/moe.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..4c0d6c9ada269bd9740e7df1f234d56ae652d1d5 Binary files /dev/null and b/model/__pycache__/moe.cpython-38.pyc differ diff --git a/model/__pycache__/rope.cpython-310.pyc b/model/__pycache__/rope.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..df584e09ab2626b245169bea5271410996bf2eb4 Binary files /dev/null and b/model/__pycache__/rope.cpython-310.pyc differ diff --git a/model/__pycache__/rope.cpython-38.pyc b/model/__pycache__/rope.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..e5b4ebdfc109de6ec989e8b77e44ffcc99134042 Binary files /dev/null and b/model/__pycache__/rope.cpython-38.pyc differ diff --git a/model/__pycache__/transformer.cpython-310.pyc b/model/__pycache__/transformer.cpython-310.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b589f6fad5cf12e308314ca671a7090d394221bd Binary files /dev/null and b/model/__pycache__/transformer.cpython-310.pyc differ diff --git a/model/__pycache__/transformer.cpython-38.pyc b/model/__pycache__/transformer.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..b921c06832ab3adb1a31b6fc70fd2ff9a76cb1e4 Binary files /dev/null and b/model/__pycache__/transformer.cpython-38.pyc differ diff --git a/model/args.py b/model/args.py new file mode 100644 index 0000000000000000000000000000000000000000..4b7fbbb96559dab0098a9637516efaff15a54e59 --- /dev/null +++ b/model/args.py @@ -0,0 +1,39 @@ +from dataclasses import dataclass, field +from typing import Optional + +from simple_parsing.helpers import Serializable + + +@dataclass +class LoraArgs(Serializable): + enable: bool = True + rank: int = 16 + dropout: float = 0.0 + scaling: float = 2.0 + + def __post_init__(self): + if self.enable: + assert self.rank > 0 + assert self.scaling > 0.0 + + +@dataclass +class MoeArgs(Serializable): + num_experts: int = 8 + num_experts_per_tok: int = 2 + + +@dataclass +class ModelArgs(Serializable): + dim: int + n_layers: int + head_dim: int + hidden_dim: int + n_heads: int + n_kv_heads: int + norm_eps: float + vocab_size: int + rope_theta: float = 10000.0 + + lora: LoraArgs = field(default_factory=LoraArgs) + moe: Optional[MoeArgs] = None diff --git a/model/lora.py b/model/lora.py new file mode 100644 index 0000000000000000000000000000000000000000..d376df63194fa6540285be680728c00c3b124bb9 --- /dev/null +++ b/model/lora.py @@ -0,0 +1,96 @@ +from typing import NamedTuple + +import torch +import torch.nn as nn + + +class LoRALinear(nn.Module): + """ + Implementation of: + - LoRA: https://arxiv.org/abs/2106.09685 + + Notes: + - Freezing is handled at network level, not layer level. + - Scaling factor controls relative importance of LoRA skip + connection versus original frozen weight. General guidance is + to keep it to 2.0 and sweep over learning rate when changing + the rank. + """ + + def __init__( + self, + in_features: int, + out_features: int, + rank: int, + scaling: float, + dropout: float, + bias: bool = False, + ): + super().__init__() + + self.in_features = in_features + self.out_features = out_features + assert not bias + self.bias = bias + self.rank = rank + self.scaling = scaling + + self.dropout = nn.Dropout(p=dropout) + + self.lora_A = nn.Linear( + self.in_features, + self.rank, + bias=self.bias, + ) + self.lora_B = nn.Linear( + self.rank, + self.out_features, + bias=self.bias, + ) + + self.frozen_W = nn.Linear(self.in_features, self.out_features, bias=self.bias) + + # make sure no LoRA weights are marked as "missing" in load_state_dict + def ignore_missing_keys(m: nn.Module, incompatible_keys: NamedTuple): + # empty missing keys in place + incompatible_keys.missing_keys[:] = [] # type: ignore + + self.register_load_state_dict_post_hook(ignore_missing_keys) + + def merge_weight(self): + with torch.no_grad(): + down_weight = self.lora_A.weight + up_weight = self.lora_B.weight + + weight = up_weight.mm(down_weight) * self.scaling + + weight += self.frozen_W.weight + return weight + + def _load_from_state_dict( + self, + state_dict, + prefix, + local_metadata, + strict, + missing_keys, + unexpected_keys, + error_msgs, + ): + key_name = prefix + "weight" + + # full checkpoint + if key_name in state_dict: + w_ref = state_dict[key_name] + + # load frozen weights + self.frozen_W.load_state_dict({"weight": w_ref}, assign=True) + + def forward(self, x: torch.Tensor): + lora = self.lora_B(self.lora_A(self.dropout(x))) + return self.frozen_W(x) + lora * self.scaling + + def __repr__(self) -> str: + return "{}Linear(in_features={}, out_features={}, r={}, dropout={})".format( + "LoRA", self.in_features, self.out_features, self.rank, self.dropout.p + ) diff --git a/model/moe.py b/model/moe.py new file mode 100644 index 0000000000000000000000000000000000000000..457933dea01bdc6ac8e8ced7943e6ef421f92623 --- /dev/null +++ b/model/moe.py @@ -0,0 +1,31 @@ +from typing import List + +import torch +import torch.nn as nn + +from .args import MoeArgs + + +class MoeLayer(nn.Module): + def __init__(self, experts: List[nn.Module], gate: nn.Module, moe_args: MoeArgs): + super().__init__() + assert len(experts) > 0 + self.experts = nn.ModuleList(experts) + self.gate = gate + self.args = moe_args + + def forward(self, inputs: torch.Tensor): + gate_logits = self.gate(inputs) + weights, selected_experts = torch.topk( + gate_logits, self.args.num_experts_per_tok + ) + weights = torch.nn.functional.softmax(weights, dim=1, dtype=torch.float).to( + inputs.dtype + ) + results = torch.zeros_like(inputs) + for i, expert in enumerate(self.experts): + batch_idx, nth_expert = torch.where(selected_experts == i) + results[batch_idx] += weights[batch_idx, nth_expert, None] * expert( + inputs[batch_idx] + ) + return results diff --git a/model/rope.py b/model/rope.py new file mode 100644 index 0000000000000000000000000000000000000000..2d693e26f698f4b20e8b7b3aaea18b855b43c3db --- /dev/null +++ b/model/rope.py @@ -0,0 +1,27 @@ +from typing import Optional, Tuple + +import torch + + +def precompute_freqs_cis( + dim: int, end: int, theta: float, device: Optional[torch.device] = None +) -> torch.Tensor: + freqs = 1.0 / ( + theta ** (torch.arange(0, dim, 2, device=device)[: (dim // 2)].float() / dim) + ) + t = torch.arange(end, device=freqs.device) # type: ignore + freqs = torch.outer(t, freqs).float() # type: ignore + return torch.polar(torch.ones_like(freqs), freqs) # complex64 + + +def apply_rotary_emb( + xq: torch.Tensor, + xk: torch.Tensor, + freqs_cis: torch.Tensor, +) -> Tuple[torch.Tensor, torch.Tensor]: + xq_ = torch.view_as_complex(xq.float().reshape(*xq.shape[:-1], -1, 2)) + xk_ = torch.view_as_complex(xk.float().reshape(*xk.shape[:-1], -1, 2)) + freqs_cis = freqs_cis[:, None, :] + xq_out = torch.view_as_real(xq_ * freqs_cis).flatten(2) + xk_out = torch.view_as_real(xk_ * freqs_cis).flatten(2) + return xq_out.type_as(xq), xk_out.type_as(xk) diff --git a/model/transformer.py b/model/transformer.py new file mode 100644 index 0000000000000000000000000000000000000000..82d2f1cd79ef8dc0deefc31832d6daece3dc3279 --- /dev/null +++ b/model/transformer.py @@ -0,0 +1,230 @@ +import operator +from functools import partial, reduce +from typing import Iterable, List, Optional + +import torch +import torch.distributed.algorithms._checkpoint.checkpoint_wrapper as torch_ckpt +import torch.nn as nn +from xformers.ops.fmha import memory_efficient_attention +from xformers.ops.fmha.attn_bias import AttentionBias, BlockDiagonalCausalMask + +from .args import ModelArgs +from .lora import LoRALinear +from .moe import MoeLayer +from .rope import apply_rotary_emb, precompute_freqs_cis + + +def repeat_kv(keys: torch.Tensor, values: torch.Tensor, repeats: int, dim: int): + keys = torch.repeat_interleave(keys, repeats=repeats, dim=dim) + values = torch.repeat_interleave(values, repeats=repeats, dim=dim) + return keys, values + + +def maybe_lora_layer( + args: ModelArgs, rank: Optional[int] = None +) -> partial[LoRALinear] | type[nn.Linear]: + MaybeLora: partial[LoRALinear] | type[nn.Linear] + if not args.lora.enable: + return nn.Linear + + rank = rank or args.lora.rank + scaling = args.lora.scaling + dropout = args.lora.dropout + + MaybeLora = partial( + LoRALinear, + rank=rank, + scaling=scaling, + dropout=dropout, + ) + + return MaybeLora + + +class Attention(nn.Module): + def __init__(self, args: ModelArgs): + super().__init__() + self.args = args + + self.n_heads: int = args.n_heads + self.n_kv_heads: int = args.n_kv_heads + self.head_dim: int = args.head_dim + + self.repeats = self.n_heads // self.n_kv_heads + + self.scale = self.args.head_dim**-0.5 + + MaybeLora = maybe_lora_layer(args) + + self.wq = MaybeLora(args.dim, args.n_heads * args.head_dim, bias=False) + self.wk = MaybeLora(args.dim, args.n_kv_heads * args.head_dim, bias=False) + self.wv = MaybeLora(args.dim, args.n_kv_heads * args.head_dim, bias=False) + + self.wo = MaybeLora(args.n_heads * args.head_dim, args.dim, bias=False) + + def forward( + self, + x: torch.Tensor, + freqs_cis: torch.Tensor, + mask: AttentionBias, + ) -> torch.Tensor: + seqlen_sum, _ = x.shape + + xq, xk, xv = self.wq(x), self.wk(x), self.wv(x) + + xq = xq.view(seqlen_sum, self.n_heads, self.args.head_dim) + xk = xk.view(seqlen_sum, self.n_kv_heads, self.args.head_dim) + xv = xv.view(seqlen_sum, self.n_kv_heads, self.args.head_dim) + xq, xk = apply_rotary_emb(xq, xk, freqs_cis=freqs_cis) + + key, val = xk, xv + + # Repeat keys and values to match number of query heads + key, val = repeat_kv(key, val, self.repeats, dim=1) + + # xformers requires (B=1, S, H, D) + xq, key, val = xq[None, ...], key[None, ...], val[None, ...] + output = memory_efficient_attention(xq, key, val, mask) + + return self.wo(output.view(seqlen_sum, -1)) + + +class FeedForward(nn.Module): + def __init__(self, args: ModelArgs): + super().__init__() + + MaybeLora = maybe_lora_layer(args) + self.w1 = MaybeLora(args.dim, args.hidden_dim, bias=False) + self.w2 = MaybeLora(args.hidden_dim, args.dim, bias=False) + self.w3 = MaybeLora(args.dim, args.hidden_dim, bias=False) + + def forward(self, x) -> torch.Tensor: + return self.w2(nn.functional.silu(self.w1(x)) * self.w3(x)) + + +class RMSNorm(torch.nn.Module): + def __init__(self, dim: int, eps: float = 1e-6): + super().__init__() + self.eps = eps + self.weight = nn.Parameter(torch.ones(dim)) + + def _norm(self, x): + return x * torch.rsqrt(x.pow(2).mean(-1, keepdim=True) + self.eps) + + def forward(self, x): + output = self._norm(x.float()).type_as(x) + return output * self.weight + + +class TransformerBlock(nn.Module): + def __init__(self, args: ModelArgs): + super().__init__() + self.n_heads = args.n_heads + self.dim = args.dim + self.attention = Attention(args) + + self.feed_forward: MoeLayer | FeedForward + if args.moe is not None: + self.feed_forward = MoeLayer( + experts=[FeedForward(args=args) for _ in range(args.moe.num_experts)], + gate=nn.Linear(args.dim, args.moe.num_experts, bias=False), + moe_args=args.moe, + ) + else: + self.feed_forward = FeedForward(args=args) + + self.attention_norm = RMSNorm(args.dim, eps=args.norm_eps) + self.ffn_norm = RMSNorm(args.dim, eps=args.norm_eps) + self.args = args + + def forward( + self, + x: torch.Tensor, + freqs_cis: torch.Tensor, + att_mask: AttentionBias, + ) -> torch.Tensor: + r = self.attention(self.attention_norm(x), freqs_cis, att_mask) + h = x + r + + r = self.feed_forward(self.ffn_norm(h)) + out = h + r + + return out + + +class Transformer(nn.Module): + def __init__(self, args: ModelArgs, checkpoint: bool = False): + super().__init__() + self.args = args + self.vocab_size = args.vocab_size + self.n_layers = args.n_layers + assert self.vocab_size > 0 + self.tok_embeddings = torch.nn.Embedding(args.vocab_size, args.dim) + self.layers = torch.nn.ModuleList() + for _ in range(args.n_layers): + block: torch.nn.Module = TransformerBlock(args=args) + if checkpoint: + # activate gradient checkpointing as, see: https://pytorch.org/docs/stable/checkpoint.html + non_reentrant_wrapper = partial( + torch_ckpt.checkpoint_wrapper, + checkpoint_impl=torch_ckpt.CheckpointImpl.NO_REENTRANT, + ) + block = non_reentrant_wrapper(block) + + self.layers.append(block) + + self.norm = RMSNorm(args.dim, eps=args.norm_eps) + + self.output = torch.nn.Linear( + args.dim, + args.vocab_size, + bias=False, + ) + + # set lazily + self._freqs_cis = None + + @property + def dtype(self) -> torch.dtype: + return self.tok_embeddings.weight.dtype + + @property + def device(self) -> torch.device: + return self.tok_embeddings.weight.device + + @property + def freqs_cis(self): + # lazy init + device = next(iter(self.parameters())).device + if self._freqs_cis is None: + self._freqs_cis = precompute_freqs_cis( + self.args.head_dim, 128_000, theta=self.args.rope_theta, device=device + ) + + return self._freqs_cis + + def forward( + self, + input_ids: torch.Tensor, + seqlens: List[int], + ) -> torch.Tensor: + assert sum(seqlens) == input_ids.shape[0], (sum(seqlens), input_ids.shape[0]) + + h = self.tok_embeddings(input_ids) + positions = positions_from_sizes(seqlens, self.freqs_cis.device) + att_mask = BlockDiagonalCausalMask.from_seqlens(seqlens) + + freqs_cis = self.freqs_cis[positions].to(device=h.device) + + for layer in self.layers: + h = layer(h, freqs_cis, att_mask) + + return self.output(self.norm(h)).float() + + +def positions_from_sizes(sizes: Iterable[int], device): + return torch.tensor( + reduce(operator.iadd, [list(range(s)) for s in sizes], []), + dtype=torch.long, + device=device, + ) diff --git a/pyproject.toml b/pyproject.toml new file mode 100644 index 0000000000000000000000000000000000000000..c6f223d5df0d91f9d7711fa6d095be324b483e42 --- /dev/null +++ b/pyproject.toml @@ -0,0 +1,51 @@ +[tool.black] +include = '\.pyi?$' +exclude = ''' +/( + \.git + | \.hg + | \.mypy_cache + | \.tox + | \.venv + | _build + | buck-out + | build + | dist +)/ +''' +line-length = 88 + +[tool.isort] +known_third_party = [] +line_length = 88 + +[tool.mypy] +python_version = "3.10" +ignore_missing_imports = true +follow_imports = "normal" + +[tool.ruff] +lint.select = ["E", "F", "W", "C90", "I", "C4", "PT", "RSE", "TID", "TCH", "FLY", "NPY", "RUF", "T10"] +line-length = 88 +lint.ignore = ["E501"] +target-version = "py38" +exclude = [".git","__pycache__",".vscode",".mypy_cache"] + +[tool.ruff.lint.mccabe] +max-complexity = 20 + +[tool.pytest.ini_options] +python_classes = [ + "!TestConfig", +] +filterwarnings = [ + "error", + "ignore::DeprecationWarning", + "ignore::ImportWarning", + "ignore::DeprecationWarning:pkg_resources", + "ignore::DeprecationWarning:wandb", + "ignore::DeprecationWarning:torch.utils.tensorboard", + "ignore::UserWarning", +] +testpaths = [] +addopts = "--ignore=third_party --ignore=tokens" diff --git a/requirements.dev.txt b/requirements.dev.txt new file mode 100644 index 0000000000000000000000000000000000000000..d1bcbd301a4e5b78635a3417ab3cb129bbdb974c --- /dev/null +++ b/requirements.dev.txt @@ -0,0 +1,5 @@ +mypy==1.4.0 +mypy-extensions==1.0.0 +pre-commit +ruff==0.0.282 +pytest diff --git a/requirements.txt b/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..a5cdf885e21be0e8ed785a5b0ba9f70181eac378 --- /dev/null +++ b/requirements.txt @@ -0,0 +1,11 @@ +fire +simple-parsing +pyyaml +mistral-common>=1.1.0 +safetensors +tensorboard +tqdm + +torch==2.2 +triton==2.2 +xformers==0.0.24 diff --git a/runs/args.yaml b/runs/args.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ae2759ccef489927de149d37a4d15533c773b0ba --- /dev/null +++ b/runs/args.yaml @@ -0,0 +1,42 @@ +batch_size: 1 +checkpoint: true +ckpt_freq: 100 +ckpt_only_lora: true +data: + data: '' + eval_instruct_data: '' + instruct: + dynamic_chunk_fn_call: true + shuffle: true + instruct_data: /root/data/mol_instructions_train.jsonl + shuffle: false +eval_freq: 100 +log_freq: 1 +lora: + dropout: 0.0 + enable: true + rank: 64 + scaling: 2.0 +max_norm: 1.0 +max_steps: 300 +mlflow: + experiment_name: null + tracking_uri: null +model_id_or_path: /root/mistral_models/7B-v0.3 +no_ckpt: false +no_eval: true +num_ckpt_keep: 3 +num_microbatches: 1 +optim: + lr: 6.0e-05 + pct_start: 0.05 + weight_decay: 0.1 +run_dir: /root/mistral-finetune/runs +seed: 0 +seq_len: 32768 +wandb: + key: aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df + offline: false + project: CHEMISTral7b-ft + run_name: run0 +world_size: 1 diff --git a/runs/checkpoints/checkpoint_000100/consolidated/lora.safetensors b/runs/checkpoints/checkpoint_000100/consolidated/lora.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..2b975c2f77fa9b0a55f29949e3d108e0783624ad --- /dev/null +++ b/runs/checkpoints/checkpoint_000100/consolidated/lora.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:e212327d2078b2295e209d0bb538c6e80cca2e2a9ceb36463671ff3a950443db +size 335594288 diff --git a/runs/checkpoints/checkpoint_000100/consolidated/params.json b/runs/checkpoints/checkpoint_000100/consolidated/params.json new file mode 100644 index 0000000000000000000000000000000000000000..f6f914db94794fe23c78add929abbca1c57efa3c --- /dev/null +++ b/runs/checkpoints/checkpoint_000100/consolidated/params.json @@ -0,0 +1,18 @@ +{ + "dim": 4096, + "n_layers": 32, + "head_dim": 128, + "hidden_dim": 14336, + "n_heads": 32, + "n_kv_heads": 8, + "norm_eps": 1e-05, + "vocab_size": 32768, + "rope_theta": 1000000.0, + "lora": { + "enable": true, + "rank": 64, + "dropout": 0.0, + "scaling": 2.0 + }, + "moe": null +} \ No newline at end of file diff --git a/runs/checkpoints/checkpoint_000100/consolidated/tokenizer.model.v3 b/runs/checkpoints/checkpoint_000100/consolidated/tokenizer.model.v3 new file mode 100644 index 0000000000000000000000000000000000000000..d8233e5b061987d32b63dbfb38fe86d7d4fc8a18 Binary files /dev/null and b/runs/checkpoints/checkpoint_000100/consolidated/tokenizer.model.v3 differ diff --git a/runs/checkpoints/checkpoint_000200/consolidated/lora.safetensors b/runs/checkpoints/checkpoint_000200/consolidated/lora.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..9ab93b46f2d220145341d18a0c921982b5ec34ab --- /dev/null +++ b/runs/checkpoints/checkpoint_000200/consolidated/lora.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:2f365196fc95b81d19804e71071fd6d07a83b40e646f762adb1cd8623246d2af +size 335594288 diff --git a/runs/checkpoints/checkpoint_000200/consolidated/params.json b/runs/checkpoints/checkpoint_000200/consolidated/params.json new file mode 100644 index 0000000000000000000000000000000000000000..f6f914db94794fe23c78add929abbca1c57efa3c --- /dev/null +++ b/runs/checkpoints/checkpoint_000200/consolidated/params.json @@ -0,0 +1,18 @@ +{ + "dim": 4096, + "n_layers": 32, + "head_dim": 128, + "hidden_dim": 14336, + "n_heads": 32, + "n_kv_heads": 8, + "norm_eps": 1e-05, + "vocab_size": 32768, + "rope_theta": 1000000.0, + "lora": { + "enable": true, + "rank": 64, + "dropout": 0.0, + "scaling": 2.0 + }, + "moe": null +} \ No newline at end of file diff --git a/runs/checkpoints/checkpoint_000200/consolidated/tokenizer.model.v3 b/runs/checkpoints/checkpoint_000200/consolidated/tokenizer.model.v3 new file mode 100644 index 0000000000000000000000000000000000000000..d8233e5b061987d32b63dbfb38fe86d7d4fc8a18 Binary files /dev/null and b/runs/checkpoints/checkpoint_000200/consolidated/tokenizer.model.v3 differ diff --git a/runs/checkpoints/checkpoint_000300/consolidated/lora.safetensors b/runs/checkpoints/checkpoint_000300/consolidated/lora.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..40006de4eaadac0d3903e3d10d3ee0883999a29c --- /dev/null +++ b/runs/checkpoints/checkpoint_000300/consolidated/lora.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3c1a98172203a682f22a574d0c39ea290d48b9d68794b20c5d35f73de8836ecc +size 335594288 diff --git a/runs/checkpoints/checkpoint_000300/consolidated/params.json b/runs/checkpoints/checkpoint_000300/consolidated/params.json new file mode 100644 index 0000000000000000000000000000000000000000..f6f914db94794fe23c78add929abbca1c57efa3c --- /dev/null +++ b/runs/checkpoints/checkpoint_000300/consolidated/params.json @@ -0,0 +1,18 @@ +{ + "dim": 4096, + "n_layers": 32, + "head_dim": 128, + "hidden_dim": 14336, + "n_heads": 32, + "n_kv_heads": 8, + "norm_eps": 1e-05, + "vocab_size": 32768, + "rope_theta": 1000000.0, + "lora": { + "enable": true, + "rank": 64, + "dropout": 0.0, + "scaling": 2.0 + }, + "moe": null +} \ No newline at end of file diff --git a/runs/checkpoints/checkpoint_000300/consolidated/tokenizer.model.v3 b/runs/checkpoints/checkpoint_000300/consolidated/tokenizer.model.v3 new file mode 100644 index 0000000000000000000000000000000000000000..d8233e5b061987d32b63dbfb38fe86d7d4fc8a18 Binary files /dev/null and b/runs/checkpoints/checkpoint_000300/consolidated/tokenizer.model.v3 differ diff --git a/runs/metrics.train.jsonl b/runs/metrics.train.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..e5efc47007587e4307b555c99467f07d022e9d12 --- /dev/null +++ b/runs/metrics.train.jsonl @@ -0,0 +1,300 @@ +{"lr": 2.3999999999999974e-06, "step": 1, "loss": 2.0530354976654053, "percent_done": 0.3333333333333333, "peak_allocated_mem": 39.05608654022217, "allocated_mem": 20.13806438446045, "wps": 45.00039550390461, "avg_wps": 45.00039550390461, "eta_in_seconds": 217723.2419912815, "at": "2024-05-25T19:38:50.621944"} +{"lr": 3.122076129163481e-06, "step": 2, "loss": 2.260298013687134, "percent_done": 0.6666666666666666, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5705.092280777856, "avg_wps": 89.29644215309918, "eta_in_seconds": 109353.33776521683, "at": "2024-05-25T19:38:56.366806"} +{"lr": 5.2520966044103265e-06, "step": 3, "loss": 2.2447800636291504, "percent_done": 1.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5654.576453487977, "avg_wps": 132.89532910485252, "eta_in_seconds": 73231.28710055351, "at": "2024-05-25T19:39:02.162993"} +{"lr": 8.683253304920738e-06, "step": 4, "loss": 2.135059118270874, "percent_done": 1.3333333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026117324829, "wps": 5650.866369519725, "avg_wps": 175.8155138312853, "eta_in_seconds": 55167.64583873749, "at": "2024-05-25T19:39:07.962980"} +{"lr": 1.324349370646847e-05, "step": 5, "loss": 2.017400026321411, "percent_done": 1.6666666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.1405668258667, "wps": 5630.552002398738, "avg_wps": 218.06709126761814, "eta_in_seconds": 44328.37593150139, "at": "2024-05-25T19:39:13.783864"} +{"lr": 1.8704148313414327e-05, "step": 6, "loss": 2.2569916248321533, "percent_done": 2.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14056396484375, "wps": 5619.456053936722, "avg_wps": 259.6652099443688, "eta_in_seconds": 37100.8191742897, "at": "2024-05-25T19:39:19.616226"} +{"lr": 2.4791397102058146e-05, "step": 7, "loss": 2.5770864486694336, "percent_done": 2.3333333333333335, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14050579071045, "wps": 5600.401218667016, "avg_wps": 300.6196830075167, "eta_in_seconds": 31937.443030834198, "at": "2024-05-25T19:39:25.468429"} +{"lr": 3.12e-05, "step": 8, "loss": 1.7408816814422607, "percent_done": 2.6666666666666665, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.141069889068604, "wps": 5601.670335603907, "avg_wps": 340.9514197454284, "eta_in_seconds": 28063.399786233902, "at": "2024-05-25T19:39:31.319328"} +{"lr": 3.760860289794185e-05, "step": 9, "loss": 2.0509636402130127, "percent_done": 3.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5599.616753835404, "avg_wps": 380.673028184377, "eta_in_seconds": 25049.024475097656, "at": "2024-05-25T19:39:37.172380"} +{"lr": 4.369585168658567e-05, "step": 10, "loss": 1.7080286741256714, "percent_done": 3.3333333333333335, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5582.4132769515045, "avg_wps": 419.7893582060202, "eta_in_seconds": 22636.8768389225, "at": "2024-05-25T19:39:43.043467"} +{"lr": 4.915650629353153e-05, "step": 11, "loss": 1.9802886247634888, "percent_done": 3.6666666666666665, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5565.015475671134, "avg_wps": 458.3110868035861, "eta_in_seconds": 20662.716379057278, "at": "2024-05-25T19:39:48.932898"} +{"lr": 5.371674669507926e-05, "step": 12, "loss": 1.3371291160583496, "percent_done": 4.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13757610321045, "wps": 5556.789738879433, "avg_wps": 496.25482711872456, "eta_in_seconds": 19016.810485839844, "at": "2024-05-25T19:39:54.831080"} +{"lr": 5.714790339558967e-05, "step": 13, "loss": 1.7385902404785156, "percent_done": 4.333333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5574.715772996365, "avg_wps": 533.6506484743439, "eta_in_seconds": 17622.795038076547, "at": "2024-05-25T19:40:00.710262"} +{"lr": 5.9277923870836525e-05, "step": 14, "loss": 2.065999746322632, "percent_done": 4.666666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5574.672132515314, "avg_wps": 570.499726234631, "eta_in_seconds": 16427.085884605134, "at": "2024-05-25T19:40:06.589469"} +{"lr": 6e-05, "step": 15, "loss": 1.8733001947402954, "percent_done": 5.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13904094696045, "wps": 5559.93932370655, "avg_wps": 606.802323109522, "eta_in_seconds": 15390.316820383072, "at": "2024-05-25T19:40:12.484254"} +{"lr": 5.999817738412078e-05, "step": 16, "loss": 1.3049430847167969, "percent_done": 5.333333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.1390061378479, "wps": 5558.776274942792, "avg_wps": 642.5794975312142, "eta_in_seconds": 14482.429078042507, "at": "2024-05-25T19:40:18.380289"} +{"lr": 5.999270975794592e-05, "step": 17, "loss": 2.023951530456543, "percent_done": 5.666666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879632949829, "wps": 5547.978164438417, "avg_wps": 677.8339489070769, "eta_in_seconds": 13680.849144472797, "at": "2024-05-25T19:40:24.287809"} +{"lr": 5.99835977858369e-05, "step": 18, "loss": 1.9609007835388184, "percent_done": 6.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5556.554073841441, "avg_wps": 712.5931257612242, "eta_in_seconds": 12967.534580310186, "at": "2024-05-25T19:40:30.186223"} +{"lr": 5.997084257497315e-05, "step": 19, "loss": 1.8367952108383179, "percent_done": 6.333333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5562.239643780841, "avg_wps": 746.8659131253825, "eta_in_seconds": 12328.595853931025, "at": "2024-05-25T19:40:36.078583"} +{"lr": 5.995444567521751e-05, "step": 20, "loss": 1.9847050905227661, "percent_done": 6.666666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14050579071045, "wps": 5554.846156062861, "avg_wps": 780.6503920861076, "eta_in_seconds": 11753.071660518646, "at": "2024-05-25T19:40:41.978806"} +{"lr": 5.993440907892797e-05, "step": 21, "loss": 2.008533239364624, "percent_done": 7.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5559.212473634595, "avg_wps": 813.9678546754894, "eta_in_seconds": 11231.735930953706, "at": "2024-05-25T19:40:47.874367"} +{"lr": 5.991073522071549e-05, "step": 22, "loss": 1.6453710794448853, "percent_done": 7.333333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5555.894362984009, "avg_wps": 846.820435171477, "eta_in_seconds": 10757.302990870043, "at": "2024-05-25T19:40:53.773489"} +{"lr": 5.988342697714824e-05, "step": 23, "loss": 1.6444646120071411, "percent_done": 7.666666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5549.44859089609, "avg_wps": 879.2139088084657, "eta_in_seconds": 10323.694733516031, "at": "2024-05-25T19:40:59.679425"} +{"lr": 5.985248766640204e-05, "step": 24, "loss": 1.5480047464370728, "percent_done": 8.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5546.028878389035, "avg_wps": 911.1603150510274, "eta_in_seconds": 9925.770306944847, "at": "2024-05-25T19:41:05.589031"} +{"lr": 5.9817921047857205e-05, "step": 25, "loss": 1.8115681409835815, "percent_done": 8.333333333333334, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5547.925087747619, "avg_wps": 942.674511049129, "eta_in_seconds": 9559.18495130539, "at": "2024-05-25T19:41:11.496585"} +{"lr": 5.977973132164173e-05, "step": 26, "loss": 2.1473143100738525, "percent_done": 8.666666666666666, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.141010761260986, "wps": 5553.376234084026, "avg_wps": 973.7696732964953, "eta_in_seconds": 9220.283036342034, "at": "2024-05-25T19:41:17.398383"} +{"lr": 5.9737923128120935e-05, "step": 27, "loss": 2.011218309402466, "percent_done": 9.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.140625476837158, "wps": 5548.776676873549, "avg_wps": 1004.4426480679743, "eta_in_seconds": 8906.097343842188, "at": "2024-05-25T19:41:23.305002"} +{"lr": 5.9692501547333637e-05, "step": 28, "loss": 1.7630831003189087, "percent_done": 9.333333333333334, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5548.5248910603195, "avg_wps": 1034.7067574851317, "eta_in_seconds": 8613.934272221157, "at": "2024-05-25T19:41:29.211919"} +{"lr": 5.964347209837486e-05, "step": 29, "loss": 1.592596411705017, "percent_done": 9.666666666666666, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5548.229900633288, "avg_wps": 1064.5700346326146, "eta_in_seconds": 8341.516021596975, "at": "2024-05-25T19:41:35.119168"} +{"lr": 5.9590840738725265e-05, "step": 30, "loss": 1.3481348752975464, "percent_done": 10.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13928508758545, "wps": 5543.601742746767, "avg_wps": 1094.0347309133335, "eta_in_seconds": 8086.909629106522, "at": "2024-05-25T19:41:41.031377"} +{"lr": 5.9534613863527206e-05, "step": 31, "loss": 1.8914721012115479, "percent_done": 10.333333333333334, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5553.970034681057, "avg_wps": 1123.1280043621155, "eta_in_seconds": 7848.252350368807, "at": "2024-05-25T19:41:46.932535"} +{"lr": 5.947479830480773e-05, "step": 32, "loss": 1.8649791479110718, "percent_done": 10.666666666666666, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5555.62845643344, "avg_wps": 1151.846400783342, "eta_in_seconds": 7624.127656280994, "at": "2024-05-25T19:41:52.831906"} +{"lr": 5.941140133064838e-05, "step": 33, "loss": 1.7816319465637207, "percent_done": 11.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879632949829, "wps": 5548.19854434572, "avg_wps": 1180.1848829402543, "eta_in_seconds": 7413.292719190771, "at": "2024-05-25T19:41:58.739175"} +{"lr": 5.9344430644302085e-05, "step": 34, "loss": 1.530966877937317, "percent_done": 11.333333333333334, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14102840423584, "wps": 5544.676578658376, "avg_wps": 1208.155455399546, "eta_in_seconds": 7214.541771958856, "at": "2024-05-25T19:42:04.650219"} +{"lr": 5.927389438325715e-05, "step": 35, "loss": 1.9239468574523926, "percent_done": 11.666666666666666, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5549.09144127685, "avg_wps": 1235.7760634161289, "eta_in_seconds": 7026.774718386786, "at": "2024-05-25T19:42:10.556533"} +{"lr": 5.919980111824851e-05, "step": 36, "loss": 1.9826724529266357, "percent_done": 12.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.141088008880615, "wps": 5560.163129243505, "avg_wps": 1263.0633054878474, "eta_in_seconds": 6849.0248765945435, "at": "2024-05-25T19:42:16.451134"} +{"lr": 5.9122159852216236e-05, "step": 37, "loss": 1.230391025543213, "percent_done": 12.333333333333334, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.141321659088135, "wps": 5554.594941578101, "avg_wps": 1290.000228638584, "eta_in_seconds": 6680.606567872537, "at": "2024-05-25T19:42:22.351671"} +{"lr": 5.9040980019211715e-05, "step": 38, "loss": 1.589679479598999, "percent_done": 12.666666666666666, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13889980316162, "wps": 5550.529057891078, "avg_wps": 1316.5950919736158, "eta_in_seconds": 6520.771687771145, "at": "2024-05-25T19:42:28.256447"} +{"lr": 5.8956271483251227e-05, "step": 39, "loss": 2.4297244548797607, "percent_done": 13.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026117324829, "wps": 5534.849965400884, "avg_wps": 1342.8363989532324, "eta_in_seconds": 6368.942640121167, "at": "2024-05-25T19:42:34.177866"} +{"lr": 5.8868044537117476e-05, "step": 40, "loss": 1.570996880531311, "percent_done": 13.333333333333334, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5548.868526141228, "avg_wps": 1368.7746149068787, "eta_in_seconds": 6224.311809420586, "at": "2024-05-25T19:42:40.084400"} +{"lr": 5.877630990110887e-05, "step": 41, "loss": 1.558824062347412, "percent_done": 13.666666666666666, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5531.884143818491, "avg_wps": 1394.368635179955, "eta_in_seconds": 6086.562610399432, "at": "2024-05-25T19:42:46.008987"} +{"lr": 5.868107872173695e-05, "step": 42, "loss": 1.157538890838623, "percent_done": 14.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.138704299926758, "wps": 5534.133448204521, "avg_wps": 1419.6534094516157, "eta_in_seconds": 5955.076037372862, "at": "2024-05-25T19:42:51.931153"} +{"lr": 5.8582362570371976e-05, "step": 43, "loss": 1.1592546701431274, "percent_done": 14.333333333333334, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14130687713623, "wps": 5555.445660444, "avg_wps": 1444.6648356915052, "eta_in_seconds": 5829.293959362562, "at": "2024-05-25T19:42:57.830666"} +{"lr": 5.848017344183693e-05, "step": 44, "loss": 1.9465882778167725, "percent_done": 14.666666666666666, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.140945434570312, "wps": 5551.004991257424, "avg_wps": 1469.368498601663, "eta_in_seconds": 5708.988594748757, "at": "2024-05-25T19:43:03.734902"} +{"lr": 5.8374523752950034e-05, "step": 45, "loss": 1.767539381980896, "percent_done": 15.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5550.52233308678, "avg_wps": 1493.7759286830776, "eta_in_seconds": 5593.77068511645, "at": "2024-05-25T19:43:09.639618"} +{"lr": 5.8265426341016024e-05, "step": 46, "loss": 1.3011630773544312, "percent_done": 15.333333333333334, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5544.804754819244, "avg_wps": 1517.883851038684, "eta_in_seconds": 5483.339185870212, "at": "2024-05-25T19:43:15.550454"} +{"lr": 5.8152894462266266e-05, "step": 47, "loss": 1.633113980293274, "percent_done": 15.666666666666666, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5544.159460340705, "avg_wps": 1541.705473846096, "eta_in_seconds": 5377.359126395368, "at": "2024-05-25T19:43:21.462055"} +{"lr": 5.8036941790248074e-05, "step": 48, "loss": 1.8543325662612915, "percent_done": 16.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5549.59513860809, "avg_wps": 1565.255888872762, "eta_in_seconds": 5275.518245100975, "at": "2024-05-25T19:43:27.367877"} +{"lr": 5.791758241416322e-05, "step": 49, "loss": 1.856332540512085, "percent_done": 16.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5550.681042813871, "avg_wps": 1588.5329709783573, "eta_in_seconds": 5177.587214280148, "at": "2024-05-25T19:43:33.272480"} +{"lr": 5.779483083715599e-05, "step": 50, "loss": 1.3106071949005127, "percent_done": 16.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.1407413482666, "wps": 5532.281169704782, "avg_wps": 1611.5086078796783, "eta_in_seconds": 5083.435459136963, "at": "2024-05-25T19:43:39.196708"} +{"lr": 5.766870197455095e-05, "step": 51, "loss": 2.0063111782073975, "percent_done": 17.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5551.249602990137, "avg_wps": 1634.250434776576, "eta_in_seconds": 4992.644839721568, "at": "2024-05-25T19:43:45.100754"} +{"lr": 5.7539211152040574e-05, "step": 52, "loss": 1.6849699020385742, "percent_done": 17.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5542.731846850378, "avg_wps": 1656.7166059941894, "eta_in_seconds": 4905.162398081559, "at": "2024-05-25T19:43:51.013878"} +{"lr": 5.740637410382311e-05, "step": 53, "loss": 1.1660104990005493, "percent_done": 17.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.138920783996582, "wps": 5544.152974607554, "avg_wps": 1678.9284392498455, "eta_in_seconds": 4820.751028326322, "at": "2024-05-25T19:43:56.925457"} +{"lr": 5.727020697069067e-05, "step": 54, "loss": 2.070488691329956, "percent_done": 18.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13977289199829, "wps": 5522.3546155748545, "avg_wps": 1700.8497461432587, "eta_in_seconds": 4739.353383964962, "at": "2024-05-25T19:44:02.860332"} +{"lr": 5.7130726298068044e-05, "step": 55, "loss": 1.3634133338928223, "percent_done": 18.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5544.324739833485, "avg_wps": 1722.5611223025644, "eta_in_seconds": 4660.595142928037, "at": "2024-05-25T19:44:08.771746"} +{"lr": 5.6987949034002265e-05, "step": 56, "loss": 1.4657618999481201, "percent_done": 18.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.139267921447754, "wps": 5531.703797545183, "avg_wps": 1744.006234804505, "eta_in_seconds": 4584.497371877943, "at": "2024-05-25T19:44:14.696610"} +{"lr": 5.6841892527103325e-05, "step": 57, "loss": 1.318424105644226, "percent_done": 19.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.140742301940918, "wps": 5545.708419489714, "avg_wps": 1765.2361875262693, "eta_in_seconds": 4510.79807691825, "at": "2024-05-25T19:44:20.606523"} +{"lr": 5.669257452443612e-05, "step": 58, "loss": 2.13183856010437, "percent_done": 19.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13977336883545, "wps": 5526.44108846949, "avg_wps": 1786.1957643585, "eta_in_seconds": 4439.522340289478, "at": "2024-05-25T19:44:26.537053"} +{"lr": 5.654001316936406e-05, "step": 59, "loss": 1.4202699661254883, "percent_done": 19.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13892126083374, "wps": 5556.42445535892, "avg_wps": 1806.9770738737766, "eta_in_seconds": 4370.331043033277, "at": "2024-05-25T19:44:32.435546"} +{"lr": 5.638422699934453e-05, "step": 60, "loss": 2.1346490383148193, "percent_done": 20.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13902711868286, "wps": 5549.2554465605945, "avg_wps": 1827.5176060790864, "eta_in_seconds": 4303.280019760132, "at": "2024-05-25T19:44:38.341724"} +{"lr": 5.6225234943676396e-05, "step": 61, "loss": 1.7244846820831299, "percent_done": 20.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879632949829, "wps": 5537.9392412038715, "avg_wps": 1847.8132728787155, "eta_in_seconds": 4238.281061700133, "at": "2024-05-25T19:44:44.260007"} +{"lr": 5.606305632119994e-05, "step": 62, "loss": 1.7342472076416016, "percent_done": 20.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5524.431848093689, "avg_wps": 1867.863271623433, "eta_in_seconds": 4175.243508708092, "at": "2024-05-25T19:44:50.192657"} +{"lr": 5.589771083794951e-05, "step": 63, "loss": 1.5483983755111694, "percent_done": 21.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5548.935510817237, "avg_wps": 1887.7409893597335, "eta_in_seconds": 4113.9203120413285, "at": "2024-05-25T19:44:56.099130"} +{"lr": 5.5729218584759005e-05, "step": 64, "loss": 1.6664295196533203, "percent_done": 21.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001703262329, "wps": 5548.166292533978, "avg_wps": 1907.403761207345, "eta_in_seconds": 4054.331944435835, "at": "2024-05-25T19:45:02.006414"} +{"lr": 5.555760003482075e-05, "step": 65, "loss": 1.5297743082046509, "percent_done": 21.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13946771621704, "wps": 5551.54872674317, "avg_wps": 1926.8626886911495, "eta_in_seconds": 3996.38232926222, "at": "2024-05-25T19:45:07.910116"} +{"lr": 5.538287604119777e-05, "step": 66, "loss": 1.5542051792144775, "percent_done": 22.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026117324829, "wps": 5554.28561304601, "avg_wps": 1946.120000632947, "eta_in_seconds": 3939.99958764423, "at": "2024-05-25T19:45:13.810931"} +{"lr": 5.5205067834290015e-05, "step": 67, "loss": 1.9265718460083008, "percent_done": 22.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026117324829, "wps": 5537.5202072073325, "avg_wps": 1965.1425064769935, "eta_in_seconds": 3885.185921548018, "at": "2024-05-25T19:45:19.729580"} +{"lr": 5.502419701925464e-05, "step": 68, "loss": 2.108875274658203, "percent_done": 22.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.139400005340576, "wps": 5552.07507445105, "avg_wps": 1983.9919649819458, "eta_in_seconds": 3831.7574537501614, "at": "2024-05-25T19:45:25.632714"} +{"lr": 5.4840285573380864e-05, "step": 69, "loss": 1.7188280820846558, "percent_done": 23.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5549.600740738438, "avg_wps": 2002.6396823074695, "eta_in_seconds": 3779.7153760972233, "at": "2024-05-25T19:45:31.538516"} +{"lr": 5.465335584341953e-05, "step": 70, "loss": 1.5352168083190918, "percent_done": 23.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5563.992881565032, "avg_wps": 2021.1205629477734, "eta_in_seconds": 3728.9413299560547, "at": "2024-05-25T19:45:37.428999"} +{"lr": 5.446343054286776e-05, "step": 71, "loss": 1.9520819187164307, "percent_done": 23.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5560.062808151654, "avg_wps": 2039.4031867277151, "eta_in_seconds": 3679.4450694372954, "at": "2024-05-25T19:45:43.323673"} +{"lr": 5.42705327492091e-05, "step": 72, "loss": 1.4302716255187988, "percent_done": 24.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5548.466204056814, "avg_wps": 2057.4757792759765, "eta_in_seconds": 3631.1990037759147, "at": "2024-05-25T19:45:49.230660"} +{"lr": 5.407468590110943e-05, "step": 73, "loss": 1.5824264287948608, "percent_done": 24.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5563.648496827878, "avg_wps": 2075.3921870904296, "eta_in_seconds": 3584.062832205263, "at": "2024-05-25T19:45:55.121503"} +{"lr": 5.387591379556896e-05, "step": 74, "loss": 1.674532175064087, "percent_done": 24.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13977289199829, "wps": 5543.4769760635245, "avg_wps": 2093.087700376676, "eta_in_seconds": 3538.1068832745423, "at": "2024-05-25T19:46:01.033814"} +{"lr": 5.3674240585030686e-05, "step": 75, "loss": 1.5105432271957397, "percent_done": 25.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5561.709341577869, "avg_wps": 2110.638676259818, "eta_in_seconds": 3493.1606640815735, "at": "2024-05-25T19:46:06.926783"} +{"lr": 5.3469690774445686e-05, "step": 76, "loss": 1.5154811143875122, "percent_done": 25.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5566.655474622962, "avg_wps": 2128.02245217036, "eta_in_seconds": 3449.2267656828226, "at": "2024-05-25T19:46:12.814488"} +{"lr": 5.326228921829558e-05, "step": 77, "loss": 1.3376104831695557, "percent_done": 25.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5556.274626624315, "avg_wps": 2145.212163459693, "eta_in_seconds": 3406.3129626373193, "at": "2024-05-25T19:46:18.713183"} +{"lr": 5.3052061117572476e-05, "step": 78, "loss": 1.9306862354278564, "percent_done": 26.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074945449829, "wps": 5546.862871699447, "avg_wps": 2162.2120478388338, "eta_in_seconds": 3364.3767766769115, "at": "2024-05-25T19:46:24.621960"} +{"lr": 5.283903201671685e-05, "step": 79, "loss": 1.5005621910095215, "percent_done": 26.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5546.8798854454035, "avg_wps": 2179.042895195904, "eta_in_seconds": 3323.352659080602, "at": "2024-05-25T19:46:30.530711"} +{"lr": 5.262322780051372e-05, "step": 80, "loss": 1.4665850400924683, "percent_done": 26.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5569.142335095463, "avg_wps": 2195.7506135420003, "eta_in_seconds": 3283.1415168643, "at": "2024-05-25T19:46:36.415804"} +{"lr": 5.240467469094738e-05, "step": 81, "loss": 1.536689043045044, "percent_done": 27.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5566.127486025447, "avg_wps": 2212.2885787987093, "eta_in_seconds": 3243.7865786464126, "at": "2024-05-25T19:46:42.304049"} +{"lr": 5.2183399244015254e-05, "step": 82, "loss": 1.4641252756118774, "percent_done": 27.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13930368423462, "wps": 5559.905135904389, "avg_wps": 2228.6528587278476, "eta_in_seconds": 3205.2654463547033, "at": "2024-05-25T19:46:48.198849"} +{"lr": 5.195942834650111e-05, "step": 83, "loss": 1.9651626348495483, "percent_done": 27.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5561.528170665759, "avg_wps": 2244.8611155650606, "eta_in_seconds": 3167.5260222992265, "at": "2024-05-25T19:46:54.091891"} +{"lr": 5.1732789212708097e-05, "step": 84, "loss": 1.1450871229171753, "percent_done": 28.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14064359664917, "wps": 5567.377055669576, "avg_wps": 2260.9239843912655, "eta_in_seconds": 3130.5289558001928, "at": "2024-05-25T19:46:59.978755"} +{"lr": 5.150350938115196e-05, "step": 85, "loss": 1.2674968242645264, "percent_done": 28.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5561.265100007838, "avg_wps": 2276.820247818881, "eta_in_seconds": 3094.280282665701, "at": "2024-05-25T19:47:05.872031"} +{"lr": 5.127161671121493e-05, "step": 86, "loss": 1.4251376390457153, "percent_done": 28.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5565.132650789559, "avg_wps": 2292.5717521012093, "eta_in_seconds": 3058.7273848999375, "at": "2024-05-25T19:47:11.761239"} +{"lr": 5.103713937976054e-05, "step": 87, "loss": 1.8086148500442505, "percent_done": 29.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5570.93560579299, "avg_wps": 2308.1845338317, "eta_in_seconds": 3023.8414206915886, "at": "2024-05-25T19:47:17.644302"} +{"lr": 5.0800105877709955e-05, "step": 88, "loss": 1.968658447265625, "percent_done": 29.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5567.115235423649, "avg_wps": 2323.6417547659394, "eta_in_seconds": 2989.624362598766, "at": "2024-05-25T19:47:23.531408"} +{"lr": 5.0560545006580004e-05, "step": 89, "loss": 1.7461957931518555, "percent_done": 29.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14050579071045, "wps": 5560.629242424445, "avg_wps": 2338.9401608871617, "eta_in_seconds": 2956.060234297527, "at": "2024-05-25T19:47:29.425357"} +{"lr": 5.031848587498364e-05, "step": 90, "loss": 1.2153626680374146, "percent_done": 30.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13977336883545, "wps": 5548.185330016399, "avg_wps": 2354.069806800182, "eta_in_seconds": 2923.141862710317, "at": "2024-05-25T19:47:35.344926"} +{"lr": 5.0073957895092984e-05, "step": 91, "loss": 1.3210588693618774, "percent_done": 30.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5569.853049104399, "avg_wps": 2369.100712896675, "eta_in_seconds": 2890.7643996385427, "at": "2024-05-25T19:47:41.229111"} +{"lr": 4.982699077906549e-05, "step": 92, "loss": 1.3446478843688965, "percent_done": 30.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.141389846801758, "wps": 5536.208402774796, "avg_wps": 2383.924359218731, "eta_in_seconds": 2859.043733348017, "at": "2024-05-25T19:47:47.149093"} +{"lr": 4.957761453543368e-05, "step": 93, "loss": 1.3343907594680786, "percent_done": 31.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5565.322620167686, "avg_wps": 2398.6683465677547, "eta_in_seconds": 2827.809025664483, "at": "2024-05-25T19:47:53.038109"} +{"lr": 4.932585946545886e-05, "step": 94, "loss": 1.2696276903152466, "percent_done": 31.333333333333332, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13977336883545, "wps": 5550.731930481238, "avg_wps": 2413.2470413780875, "eta_in_seconds": 2797.1475295563964, "at": "2024-05-25T19:47:58.942582"} +{"lr": 4.907175615944926e-05, "step": 95, "loss": 1.3432687520980835, "percent_done": 31.666666666666668, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13897466659546, "wps": 5560.884602997397, "avg_wps": 2427.711906195901, "eta_in_seconds": 2766.9839995660277, "at": "2024-05-25T19:48:04.836259"} +{"lr": 4.8815335493043095e-05, "step": 96, "loss": 1.9270511865615845, "percent_done": 32.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026117324829, "wps": 5557.77260344202, "avg_wps": 2442.0381785121886, "eta_in_seconds": 2737.333125591278, "at": "2024-05-25T19:48:10.733263"} +{"lr": 4.8556628623456885e-05, "step": 97, "loss": 1.121458649635315, "percent_done": 32.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14065408706665, "wps": 5568.061377486646, "avg_wps": 2456.2545848097275, "eta_in_seconds": 2708.1492452523144, "at": "2024-05-25T19:48:16.619429"} +{"lr": 4.82956669856996e-05, "step": 98, "loss": 1.685607671737671, "percent_done": 32.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952875137329, "wps": 5561.805895866693, "avg_wps": 2470.3296924178676, "eta_in_seconds": 2679.454495614889, "at": "2024-05-25T19:48:22.512247"} +{"lr": 4.803248228875308e-05, "step": 99, "loss": 1.7680143117904663, "percent_done": 33.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.140581130981445, "wps": 5563.284337765982, "avg_wps": 2484.280770764261, "eta_in_seconds": 2651.217236598333, "at": "2024-05-25T19:48:28.403502"} +{"lr": 4.776710651171909e-05, "step": 100, "loss": 1.1645373106002808, "percent_done": 33.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5577.602083272967, "avg_wps": 2498.1353541806598, "eta_in_seconds": 2623.3966822624207, "at": "2024-05-25T19:48:34.279612"} +{"lr": 4.7499571899933606e-05, "step": 101, "loss": 1.2249460220336914, "percent_done": 33.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5589.179092504628, "avg_wps": 2511.8895846096525, "eta_in_seconds": 2595.986718505916, "at": "2024-05-25T19:48:40.557934"} +{"lr": 4.722991096104879e-05, "step": 102, "loss": 1.5681737661361694, "percent_done": 34.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13977336883545, "wps": 5550.491175039529, "avg_wps": 2525.4439725245056, "eta_in_seconds": 2569.0785741385293, "at": "2024-05-25T19:48:46.462664"} +{"lr": 4.695815646108298e-05, "step": 103, "loss": 1.6916416883468628, "percent_done": 34.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.140546321868896, "wps": 5578.616779554961, "avg_wps": 2538.9348184904657, "eta_in_seconds": 2542.521356983092, "at": "2024-05-25T19:48:52.337658"} +{"lr": 4.668434142043939e-05, "step": 104, "loss": 1.8946157693862915, "percent_done": 34.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5571.735319800746, "avg_wps": 2552.2930994235626, "eta_in_seconds": 2516.3755688758997, "at": "2024-05-25T19:48:58.219885"} +{"lr": 4.640849910989384e-05, "step": 105, "loss": 1.6364166736602783, "percent_done": 35.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.140563011169434, "wps": 5574.456653524034, "avg_wps": 2565.5397128840855, "eta_in_seconds": 2490.610442672457, "at": "2024-05-25T19:49:04.099265"} +{"lr": 4.613066304655207e-05, "step": 106, "loss": 1.2238625288009644, "percent_done": 35.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5571.752260592319, "avg_wps": 2578.665247063643, "eta_in_seconds": 2465.225762529193, "at": "2024-05-25T19:49:09.981476"} +{"lr": 4.58508669897772e-05, "step": 107, "loss": 1.8745325803756714, "percent_done": 35.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13909673690796, "wps": 5564.613962979488, "avg_wps": 2591.662211240346, "eta_in_seconds": 2440.219243299181, "at": "2024-05-25T19:49:15.871224"} +{"lr": 4.5569144937087604e-05, "step": 108, "loss": 2.0102040767669678, "percent_done": 36.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026117324829, "wps": 5558.867781056113, "avg_wps": 2604.5348537714226, "eta_in_seconds": 2415.5775803460015, "at": "2024-05-25T19:49:21.767076"} +{"lr": 4.5285531120025995e-05, "step": 109, "loss": 1.4501343965530396, "percent_done": 36.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026117324829, "wps": 2062.1863986428116, "avg_wps": 2598.2657197415538, "eta_in_seconds": 2408.794432550395, "at": "2024-05-25T19:49:37.658060"} +{"lr": 4.500006e-05, "step": 110, "loss": 1.7847118377685547, "percent_done": 36.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879632949829, "wps": 5594.711649402673, "avg_wps": 2610.978464925896, "eta_in_seconds": 2384.5160286209803, "at": "2024-05-25T19:49:43.516227"} +{"lr": 4.471276626409479e-05, "step": 111, "loss": 1.5799890756607056, "percent_done": 37.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5588.710907982947, "avg_wps": 2623.5718945234016, "eta_in_seconds": 2360.5802505080765, "at": "2024-05-25T19:49:49.380479"} +{"lr": 4.4423684820858324e-05, "step": 112, "loss": 1.4518753290176392, "percent_done": 37.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.141175270080566, "wps": 5578.730452152565, "avg_wps": 2636.039391823136, "eta_in_seconds": 2336.9848034552165, "at": "2024-05-25T19:49:55.255391"} +{"lr": 4.413285079605971e-05, "step": 113, "loss": 1.9266527891159058, "percent_done": 37.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5558.665212601959, "avg_wps": 2648.3619704571665, "eta_in_seconds": 2313.738102402307, "at": "2024-05-25T19:50:01.151459"} +{"lr": 4.384029952842108e-05, "step": 114, "loss": 1.293260931968689, "percent_done": 38.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001703262329, "wps": 5568.569652806519, "avg_wps": 2660.600943332158, "eta_in_seconds": 2290.7787112060346, "at": "2024-05-25T19:50:07.036976"} +{"lr": 4.354606656532369e-05, "step": 115, "loss": 1.9548749923706055, "percent_done": 38.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14050579071045, "wps": 5566.104718488182, "avg_wps": 2672.732814134493, "eta_in_seconds": 2268.120467538419, "at": "2024-05-25T19:50:12.925256"} +{"lr": 4.325018765848859e-05, "step": 116, "loss": 1.356440544128418, "percent_done": 38.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074945449829, "wps": 5554.155875920571, "avg_wps": 2684.739777124069, "eta_in_seconds": 2245.7714715497245, "at": "2024-05-25T19:50:18.826071"} +{"lr": 4.2952698759632504e-05, "step": 117, "loss": 1.4427546262741089, "percent_done": 39.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026117324829, "wps": 5524.681451974841, "avg_wps": 2696.587388939248, "eta_in_seconds": 2223.7528902628483, "at": "2024-05-25T19:50:24.758539"} +{"lr": 4.2653636016099446e-05, "step": 118, "loss": 2.062424659729004, "percent_done": 39.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14050579071045, "wps": 5549.078222693908, "avg_wps": 2708.386029431031, "eta_in_seconds": 2201.966756287268, "at": "2024-05-25T19:50:30.664873"} +{"lr": 4.235303576646844e-05, "step": 119, "loss": 1.449121356010437, "percent_done": 39.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5555.099863097919, "avg_wps": 2720.0996132219893, "eta_in_seconds": 2180.4377939580872, "at": "2024-05-25T19:50:36.564714"} +{"lr": 4.205093453613813e-05, "step": 120, "loss": 1.7226552963256836, "percent_done": 40.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5556.901400314236, "avg_wps": 2731.7208237317427, "eta_in_seconds": 2159.1664670705795, "at": "2024-05-25T19:50:42.462792"} +{"lr": 4.174736903288866e-05, "step": 121, "loss": 1.3614555597305298, "percent_done": 40.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5552.045020382834, "avg_wps": 2743.237418350122, "eta_in_seconds": 2138.156894756743, "at": "2024-05-25T19:50:48.365827"} +{"lr": 4.1442376142421335e-05, "step": 122, "loss": 1.3922536373138428, "percent_done": 40.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5554.328710456427, "avg_wps": 2754.6649471302476, "eta_in_seconds": 2117.3914475792744, "at": "2024-05-25T19:50:54.266679"} +{"lr": 4.113599292387675e-05, "step": 123, "loss": 1.622969150543213, "percent_done": 41.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026117324829, "wps": 5529.487389683492, "avg_wps": 2765.949633216106, "eta_in_seconds": 2096.9058620406363, "at": "2024-05-25T19:51:00.193937"} +{"lr": 4.0828256605331774e-05, "step": 124, "loss": 2.1181981563568115, "percent_done": 41.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14050579071045, "wps": 5548.101566070969, "avg_wps": 2777.1806450512167, "eta_in_seconds": 2076.6268878752185, "at": "2024-05-25T19:51:06.101181"} +{"lr": 4.0519204579276015e-05, "step": 125, "loss": 1.7045544385910034, "percent_done": 41.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5563.535888439569, "avg_wps": 2788.3524474707083, "eta_in_seconds": 2056.554939889908, "at": "2024-05-25T19:51:11.992213"} +{"lr": 4.020887439806836e-05, "step": 126, "loss": 1.196149468421936, "percent_done": 42.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5552.676672819206, "avg_wps": 2799.413158563198, "eta_in_seconds": 2036.7240121591658, "at": "2024-05-25T19:51:17.894609"} +{"lr": 3.9897303769374056e-05, "step": 127, "loss": 1.646715521812439, "percent_done": 42.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5537.331908002074, "avg_wps": 2810.354672330707, "eta_in_seconds": 2017.1347253116096, "at": "2024-05-25T19:51:23.813510"} +{"lr": 3.958453055158289e-05, "step": 128, "loss": 1.4321250915527344, "percent_done": 42.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5552.44808597246, "avg_wps": 2821.239655175462, "eta_in_seconds": 1997.7374093905091, "at": "2024-05-25T19:51:29.716300"} +{"lr": 3.92705927492091e-05, "step": 129, "loss": 0.9646865725517273, "percent_done": 43.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5540.168907588803, "avg_wps": 2832.013743908677, "eta_in_seconds": 1978.5666690538096, "at": "2024-05-25T19:51:35.632126"} +{"lr": 3.8955528508273524e-05, "step": 130, "loss": 1.658687710762024, "percent_done": 43.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5542.766717916678, "avg_wps": 2842.7080410804747, "eta_in_seconds": 1959.5962439683767, "at": "2024-05-25T19:51:41.545144"} +{"lr": 3.863937611166851e-05, "step": 131, "loss": 1.339421033859253, "percent_done": 43.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5562.290743604288, "avg_wps": 2853.3576460642053, "eta_in_seconds": 1940.7984160830958, "at": "2024-05-25T19:51:47.437296"} +{"lr": 3.8322173974506286e-05, "step": 132, "loss": 1.5428470373153687, "percent_done": 44.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879632949829, "wps": 5539.24851735105, "avg_wps": 2863.8777020219222, "eta_in_seconds": 1922.2273339791732, "at": "2024-05-25T19:51:53.354168"} +{"lr": 3.800396063945117e-05, "step": 133, "loss": 1.5601155757904053, "percent_done": 44.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026117324829, "wps": 5550.255371520221, "avg_wps": 2874.337909160001, "eta_in_seconds": 1903.8318294313617, "at": "2024-05-25T19:51:59.259244"} +{"lr": 3.76847747720363e-05, "step": 134, "loss": 1.3003480434417725, "percent_done": 44.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5550.48736436711, "avg_wps": 2884.7174400884765, "eta_in_seconds": 1885.622461461309, "at": "2024-05-25T19:52:05.163934"} +{"lr": 3.736465515596552e-05, "step": 135, "loss": 1.6512588262557983, "percent_done": 45.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5549.021092254631, "avg_wps": 2895.0138118786704, "eta_in_seconds": 1867.597307417128, "at": "2024-05-25T19:52:11.070428"} +{"lr": 3.704364068840078e-05, "step": 136, "loss": 1.4865667819976807, "percent_done": 45.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5551.356333104112, "avg_wps": 2905.235612840316, "eta_in_seconds": 1849.7473926894804, "at": "2024-05-25T19:52:16.974329"} +{"lr": 3.6721770375235835e-05, "step": 137, "loss": 1.4173752069473267, "percent_done": 45.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5554.816296493649, "avg_wps": 2915.3860079086135, "eta_in_seconds": 1832.0675154202174, "at": "2024-05-25T19:52:22.874440"} +{"lr": 3.639908332635672e-05, "step": 138, "loss": 1.3421114683151245, "percent_done": 46.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.138991355895996, "wps": 5528.999791413838, "avg_wps": 2925.4067992319387, "eta_in_seconds": 1814.5907097070112, "at": "2024-05-25T19:52:28.802314"} +{"lr": 3.607561875088955e-05, "step": 139, "loss": 1.4169977903366089, "percent_done": 46.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5550.598548489657, "avg_wps": 2935.394669988566, "eta_in_seconds": 1797.2533826330584, "at": "2024-05-25T19:52:34.706924"} +{"lr": 3.5751415952436323e-05, "step": 140, "loss": 1.413176417350769, "percent_done": 46.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5547.961815813612, "avg_wps": 2945.301523106464, "eta_in_seconds": 1780.0826023646764, "at": "2024-05-25T19:52:40.614483"} +{"lr": 3.542651432429918e-05, "step": 141, "loss": 1.2221511602401733, "percent_done": 47.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5552.055561698071, "avg_wps": 2955.1417578202313, "eta_in_seconds": 1763.0666908659834, "at": "2024-05-25T19:52:46.517599"} +{"lr": 3.51009533446938e-05, "step": 142, "loss": 2.0707414150238037, "percent_done": 47.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5543.865381144858, "avg_wps": 2964.8915076595395, "eta_in_seconds": 1746.217015571997, "at": "2024-05-25T19:52:52.429323"} +{"lr": 3.47747725719525e-05, "step": 143, "loss": 1.3077479600906372, "percent_done": 47.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5559.210674736536, "avg_wps": 2974.5989014463585, "eta_in_seconds": 1729.5024204771003, "at": "2024-05-25T19:52:58.324923"} +{"lr": 3.444801163971754e-05, "step": 144, "loss": 1.5891749858856201, "percent_done": 48.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5543.146528007361, "avg_wps": 2984.201680633587, "eta_in_seconds": 1712.9566118717194, "at": "2024-05-25T19:53:04.237412"} +{"lr": 3.412071025212531e-05, "step": 145, "loss": 1.951182246208191, "percent_done": 48.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026117324829, "wps": 5542.602425382893, "avg_wps": 2993.7318306734746, "eta_in_seconds": 1696.5581044904118, "at": "2024-05-25T19:53:10.150736"} +{"lr": 3.379290817898199e-05, "step": 146, "loss": 1.5253485441207886, "percent_done": 48.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5561.786764797232, "avg_wps": 3003.2296885823384, "eta_in_seconds": 1680.2817377521567, "at": "2024-05-25T19:53:16.043611"} +{"lr": 3.3464645250931154e-05, "step": 147, "loss": 1.357287883758545, "percent_done": 49.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5553.089029171717, "avg_wps": 3012.640162912752, "eta_in_seconds": 1664.1562645678616, "at": "2024-05-25T19:53:21.945589"} +{"lr": 3.313596135461402e-05, "step": 148, "loss": 1.4331635236740112, "percent_done": 49.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952875137329, "wps": 5541.871162369151, "avg_wps": 3021.958939820091, "eta_in_seconds": 1648.1812291918573, "at": "2024-05-25T19:53:27.859690"} +{"lr": 3.280689642782292e-05, "step": 149, "loss": 1.4404971599578857, "percent_done": 49.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5546.064238552954, "avg_wps": 3031.217712778995, "eta_in_seconds": 1632.3367269663202, "at": "2024-05-25T19:53:33.769080"} +{"lr": 3.247749045464852e-05, "step": 150, "loss": 1.6772619485855103, "percent_done": 50.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5554.659146157031, "avg_wps": 3040.426002911643, "eta_in_seconds": 1616.6155648231506, "at": "2024-05-25T19:53:39.669531"} +{"lr": 3.214778346062141e-05, "step": 151, "loss": 1.9604814052581787, "percent_done": 50.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001703262329, "wps": 5547.617173396487, "avg_wps": 3049.5532591065667, "eta_in_seconds": 1601.031884070264, "at": "2024-05-25T19:53:45.577411"} +{"lr": 3.18178155078487e-05, "step": 152, "loss": 0.6539248824119568, "percent_done": 50.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5547.163985651528, "avg_wps": 3058.6133956835793, "eta_in_seconds": 1585.57600213352, "at": "2024-05-25T19:53:51.485728"} +{"lr": 3.148762669014611e-05, "step": 153, "loss": 1.5434868335723877, "percent_done": 51.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14050579071045, "wps": 5552.97729653763, "avg_wps": 3067.619645605516, "eta_in_seconds": 1570.2389984691843, "at": "2024-05-25T19:53:57.387863"} +{"lr": 3.1157257128166286e-05, "step": 154, "loss": 2.1121838092803955, "percent_done": 51.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952875137329, "wps": 5535.032968895246, "avg_wps": 3076.5252100505422, "eta_in_seconds": 1555.042677489194, "at": "2024-05-25T19:54:03.308956"} +{"lr": 3.082674696452378e-05, "step": 155, "loss": 1.609840750694275, "percent_done": 51.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5555.386602394428, "avg_wps": 3085.4073737149715, "eta_in_seconds": 1539.945759019544, "at": "2024-05-25T19:54:09.208553"} +{"lr": 3.0496136358917387e-05, "step": 156, "loss": 1.6238648891448975, "percent_done": 52.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5561.450754645733, "avg_wps": 3094.238158334836, "eta_in_seconds": 1524.9608331827017, "at": "2024-05-25T19:54:15.101649"} +{"lr": 3.016546548325044e-05, "step": 157, "loss": 1.7565937042236328, "percent_done": 52.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5553.156115784995, "avg_wps": 3102.9897055064134, "eta_in_seconds": 1510.0997569166173, "at": "2024-05-25T19:54:21.003475"} +{"lr": 2.9834774516749563e-05, "step": 158, "loss": 1.5490272045135498, "percent_done": 52.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14050531387329, "wps": 5547.809979764306, "avg_wps": 3111.6685439400067, "eta_in_seconds": 1495.3572124710565, "at": "2024-05-25T19:54:26.911106"} +{"lr": 2.9504103641082615e-05, "step": 159, "loss": 1.454077124595642, "percent_done": 53.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5551.71041049766, "avg_wps": 3120.2937370815043, "eta_in_seconds": 1480.7221336544683, "at": "2024-05-25T19:54:32.814446"} +{"lr": 2.9173493035476225e-05, "step": 160, "loss": 1.500572681427002, "percent_done": 53.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5552.377203197344, "avg_wps": 3128.8594909438116, "eta_in_seconds": 1466.1955940425396, "at": "2024-05-25T19:54:38.717278"} +{"lr": 2.884298287183371e-05, "step": 161, "loss": 1.4904091358184814, "percent_done": 53.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5553.222755263117, "avg_wps": 3137.366796272592, "eta_in_seconds": 1451.7754205250594, "at": "2024-05-25T19:54:44.619230"} +{"lr": 2.851261330985389e-05, "step": 162, "loss": 1.9589848518371582, "percent_done": 54.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5548.318820033475, "avg_wps": 3145.8048818789543, "eta_in_seconds": 1437.4648682276409, "at": "2024-05-25T19:54:50.526316"} +{"lr": 2.818242449215131e-05, "step": 163, "loss": 1.457173228263855, "percent_done": 54.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14050579071045, "wps": 5555.402994807008, "avg_wps": 3154.198136770914, "eta_in_seconds": 1423.2511102158599, "at": "2024-05-25T19:54:56.425949"} +{"lr": 2.78524565393786e-05, "step": 164, "loss": 1.3635801076889038, "percent_done": 54.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13904094696045, "wps": 5542.9249844245205, "avg_wps": 3162.5084105327724, "eta_in_seconds": 1409.1497702133363, "at": "2024-05-25T19:55:02.338652"} +{"lr": 2.7522749545351488e-05, "step": 165, "loss": 1.3658273220062256, "percent_done": 55.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5553.322156513965, "avg_wps": 3170.781643749702, "eta_in_seconds": 1395.1386430913753, "at": "2024-05-25T19:55:08.240479"} +{"lr": 2.719334357217709e-05, "step": 166, "loss": 1.2269325256347656, "percent_done": 55.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5546.32251570256, "avg_wps": 3178.9839813134863, "eta_in_seconds": 1381.2312442624425, "at": "2024-05-25T19:55:14.149682"} +{"lr": 2.6864278645385993e-05, "step": 167, "loss": 1.4539093971252441, "percent_done": 55.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5561.727571851196, "avg_wps": 3187.1602475892296, "eta_in_seconds": 1367.4066132371297, "at": "2024-05-25T19:55:20.042450"} +{"lr": 2.653559474906885e-05, "step": 168, "loss": 1.4018830060958862, "percent_done": 56.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.141101837158203, "wps": 5556.566204823446, "avg_wps": 3195.270443089468, "eta_in_seconds": 1353.6807218790054, "at": "2024-05-25T19:55:25.940957"} +{"lr": 2.620733182101801e-05, "step": 169, "loss": 1.2399303913116455, "percent_done": 56.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5550.705926094114, "avg_wps": 3203.3137709193797, "eta_in_seconds": 1340.052304263651, "at": "2024-05-25T19:55:31.845526"} +{"lr": 2.587952974787469e-05, "step": 170, "loss": 1.3772953748703003, "percent_done": 56.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5553.688603149399, "avg_wps": 3211.308222433429, "eta_in_seconds": 1326.5123447951148, "at": "2024-05-25T19:55:37.746962"} +{"lr": 2.555222836028246e-05, "step": 171, "loss": 1.6267982721328735, "percent_done": 57.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952875137329, "wps": 5537.57040761728, "avg_wps": 3219.2167112170955, "eta_in_seconds": 1313.0746946209356, "at": "2024-05-25T19:55:43.665558"} +{"lr": 2.5225467428047498e-05, "step": 172, "loss": 1.3681708574295044, "percent_done": 57.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001703262329, "wps": 5548.712608209097, "avg_wps": 3227.0935658196872, "eta_in_seconds": 1299.7156464332759, "at": "2024-05-25T19:55:49.572142"} +{"lr": 2.4899286655306205e-05, "step": 173, "loss": 1.6353782415390015, "percent_done": 57.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5548.847915797045, "avg_wps": 3234.917596871524, "eta_in_seconds": 1286.4426605563633, "at": "2024-05-25T19:55:55.478771"} +{"lr": 2.457372567570083e-05, "step": 174, "loss": 1.2095701694488525, "percent_done": 58.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5552.188116546422, "avg_wps": 3242.695624861009, "eta_in_seconds": 1273.2517872925462, "at": "2024-05-25T19:56:01.381801"} +{"lr": 2.4248824047563685e-05, "step": 175, "loss": 1.5379315614700317, "percent_done": 58.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5543.721371991135, "avg_wps": 3250.4050059328647, "eta_in_seconds": 1260.1506558486392, "at": "2024-05-25T19:56:07.293682"} +{"lr": 2.3924621249110454e-05, "step": 176, "loss": 1.2504979372024536, "percent_done": 58.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14103937149048, "wps": 5555.304866328905, "avg_wps": 3258.0855853638172, "eta_in_seconds": 1247.1225489757276, "at": "2024-05-25T19:56:13.193438"} +{"lr": 2.3601156673643287e-05, "step": 177, "loss": 1.5119073390960693, "percent_done": 59.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13928508758545, "wps": 5529.11434258515, "avg_wps": 3265.6637714296576, "eta_in_seconds": 1234.194418684911, "at": "2024-05-25T19:56:19.120974"} +{"lr": 2.3278469624764173e-05, "step": 178, "loss": 1.5850368738174438, "percent_done": 59.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5550.428411689847, "avg_wps": 3273.233353969072, "eta_in_seconds": 1221.3293608145768, "at": "2024-05-25T19:56:25.025912"} +{"lr": 2.2956599311599224e-05, "step": 179, "loss": 1.6369091272354126, "percent_done": 59.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.139315128326416, "wps": 5541.789153155429, "avg_wps": 3280.736056511249, "eta_in_seconds": 1208.5483049240859, "at": "2024-05-25T19:56:30.940010"} +{"lr": 2.2635584844034485e-05, "step": 180, "loss": 1.177604079246521, "percent_done": 60.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026117324829, "wps": 5546.54007803231, "avg_wps": 3288.198580156281, "eta_in_seconds": 1195.8401854832969, "at": "2024-05-25T19:56:36.848913"} +{"lr": 2.2315465227963692e-05, "step": 181, "loss": 1.5331655740737915, "percent_done": 60.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14062738418579, "wps": 5557.171922676443, "avg_wps": 3295.6328069065794, "eta_in_seconds": 1183.1997763307056, "at": "2024-05-25T19:56:42.746693"} +{"lr": 2.1996279360548834e-05, "step": 182, "loss": 1.0675721168518066, "percent_done": 60.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5555.738723712918, "avg_wps": 3303.015694020507, "eta_in_seconds": 1170.6344620159693, "at": "2024-05-25T19:56:48.645824"} +{"lr": 2.167806602549372e-05, "step": 183, "loss": 1.2934004068374634, "percent_done": 61.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14050579071045, "wps": 5552.977072179434, "avg_wps": 3310.345143739144, "eta_in_seconds": 1158.1438893920085, "at": "2024-05-25T19:56:54.548046"} +{"lr": 2.1360863888331495e-05, "step": 184, "loss": 1.863431692123413, "percent_done": 61.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5554.715494755172, "avg_wps": 3317.630367201836, "eta_in_seconds": 1145.723778506984, "at": "2024-05-25T19:57:00.448405"} +{"lr": 2.104471149172649e-05, "step": 185, "loss": 1.4430063962936401, "percent_done": 61.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13893413543701, "wps": 5540.752515711886, "avg_wps": 3324.8413385568147, "eta_in_seconds": 1133.383405788525, "at": "2024-05-25T19:57:06.363453"} +{"lr": 2.0729647250790905e-05, "step": 186, "loss": 1.0481935739517212, "percent_done": 62.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879632949829, "wps": 5546.335049694435, "avg_wps": 3332.0165249775782, "eta_in_seconds": 1121.1084855064269, "at": "2024-05-25T19:57:12.272743"} +{"lr": 2.0415709448417114e-05, "step": 187, "loss": 1.7160991430282593, "percent_done": 62.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.139798641204834, "wps": 5543.466690888596, "avg_wps": 3339.139947902624, "eta_in_seconds": 1108.903507421361, "at": "2024-05-25T19:57:18.184896"} +{"lr": 2.010293623062595e-05, "step": 188, "loss": 1.8661465644836426, "percent_done": 62.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5550.528385409914, "avg_wps": 3346.231296156538, "eta_in_seconds": 1096.761005198702, "at": "2024-05-25T19:57:24.089728"} +{"lr": 1.979136560193164e-05, "step": 189, "loss": 1.539074420928955, "percent_done": 63.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5555.389297030948, "avg_wps": 3353.286688363618, "eta_in_seconds": 1084.6814895433095, "at": "2024-05-25T19:57:29.989366"} +{"lr": 1.9481035420723993e-05, "step": 190, "loss": 1.3992009162902832, "percent_done": 63.333333333333336, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14050579071045, "wps": 5553.828642068859, "avg_wps": 3360.29415231375, "eta_in_seconds": 1072.6679976864866, "at": "2024-05-25T19:57:35.890523"} +{"lr": 1.9171983394668235e-05, "step": 191, "loss": 1.5862611532211304, "percent_done": 63.666666666666664, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5544.340843369081, "avg_wps": 3367.238837322144, "eta_in_seconds": 1060.7242825817689, "at": "2024-05-25T19:57:41.801944"} +{"lr": 1.886424707612324e-05, "step": 192, "loss": 1.7817482948303223, "percent_done": 64.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5547.314442937058, "avg_wps": 3374.145230743656, "eta_in_seconds": 1048.8416348397732, "at": "2024-05-25T19:57:47.710016"} +{"lr": 1.8557863857578663e-05, "step": 193, "loss": 1.0731173753738403, "percent_done": 64.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5539.588771558219, "avg_wps": 3380.993113495268, "eta_in_seconds": 1037.0254781073238, "at": "2024-05-25T19:57:53.626529"} +{"lr": 1.825287096711135e-05, "step": 194, "loss": 1.836398959159851, "percent_done": 64.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14116621017456, "wps": 5483.414439012588, "avg_wps": 3387.688419197737, "eta_in_seconds": 1025.3032658837506, "at": "2024-05-25T19:57:59.603500"} +{"lr": 1.794930546386188e-05, "step": 195, "loss": 1.6675441265106201, "percent_done": 65.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879632949829, "wps": 5544.138437674579, "avg_wps": 3394.4592399603807, "eta_in_seconds": 1013.6047472586998, "at": "2024-05-25T19:58:05.514968"} +{"lr": 1.7647204233531568e-05, "step": 196, "loss": 1.3504499197006226, "percent_done": 65.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.138954639434814, "wps": 5558.440178833983, "avg_wps": 3401.215066930263, "eta_in_seconds": 1001.9572220335202, "at": "2024-05-25T19:58:11.411455"} +{"lr": 1.7346603983900562e-05, "step": 197, "loss": 1.4751169681549072, "percent_done": 65.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5541.274807392465, "avg_wps": 3407.8959875774735, "eta_in_seconds": 990.3776442423691, "at": "2024-05-25T19:58:17.325962"} +{"lr": 1.7047541240367497e-05, "step": 198, "loss": 1.6267430782318115, "percent_done": 66.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14050579071045, "wps": 5552.897426165578, "avg_wps": 3414.55756661899, "eta_in_seconds": 978.8489239938332, "at": "2024-05-25T19:58:23.228383"} +{"lr": 1.6750052341511415e-05, "step": 199, "loss": 1.6427803039550781, "percent_done": 66.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5559.91323297743, "avg_wps": 3421.191262619298, "eta_in_seconds": 967.3729838378466, "at": "2024-05-25T19:58:29.123249"} +{"lr": 1.645417343467632e-05, "step": 200, "loss": 1.127903938293457, "percent_done": 66.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5539.835057732986, "avg_wps": 3427.7457648926825, "eta_in_seconds": 955.9635471105576, "at": "2024-05-25T19:58:35.039275"} +{"lr": 1.6159940471578926e-05, "step": 201, "loss": 1.734163522720337, "percent_done": 67.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5560.668388690605, "avg_wps": 3434.2995201019735, "eta_in_seconds": 944.5978666134733, "at": "2024-05-25T19:58:41.231291"} +{"lr": 1.5867389203940292e-05, "step": 202, "loss": 1.3864355087280273, "percent_done": 67.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14100408554077, "wps": 5560.198219986726, "avg_wps": 3440.812232438713, "eta_in_seconds": 933.2866146328427, "at": "2024-05-25T19:58:47.125815"} +{"lr": 1.5576555179141667e-05, "step": 203, "loss": 1.2754898071289062, "percent_done": 67.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5549.622028936912, "avg_wps": 3447.265098481514, "eta_in_seconds": 922.0341079657887, "at": "2024-05-25T19:58:53.031562"} +{"lr": 1.5287473735905225e-05, "step": 204, "loss": 1.5408432483673096, "percent_done": 68.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5558.660716244388, "avg_wps": 3453.6957260009985, "eta_in_seconds": 910.8295141107897, "at": "2024-05-25T19:58:58.927732"} +{"lr": 1.5000180000000006e-05, "step": 205, "loss": 1.8843226432800293, "percent_done": 68.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13757562637329, "wps": 5540.255335479043, "avg_wps": 3460.0523984047763, "eta_in_seconds": 899.6857970807611, "at": "2024-05-25T19:59:04.843344"} +{"lr": 1.4714708879974004e-05, "step": 206, "loss": 1.8483222723007202, "percent_done": 68.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5549.667743093974, "avg_wps": 3466.388313625655, "eta_in_seconds": 888.588271513726, "at": "2024-05-25T19:59:10.749168"} +{"lr": 1.4431095062912406e-05, "step": 207, "loss": 1.0595793724060059, "percent_done": 69.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5553.517603661535, "avg_wps": 3472.6932001019118, "eta_in_seconds": 877.5390811692114, "at": "2024-05-25T19:59:16.650785"} +{"lr": 1.4149373010222808e-05, "step": 208, "loss": 1.7123018503189087, "percent_done": 69.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14107084274292, "wps": 5559.568228605491, "avg_wps": 3478.9715124113545, "eta_in_seconds": 866.5365580733005, "at": "2024-05-25T19:59:22.545944"} +{"lr": 1.3869576953447932e-05, "step": 209, "loss": 1.363702416419983, "percent_done": 69.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5553.893502230525, "avg_wps": 3485.201480603508, "eta_in_seconds": 855.5855426423287, "at": "2024-05-25T19:59:28.447150"} +{"lr": 1.3591740890106174e-05, "step": 210, "loss": 1.1449100971221924, "percent_done": 70.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13977336883545, "wps": 5536.625453943095, "avg_wps": 3491.3615529374697, "eta_in_seconds": 844.6905183792114, "at": "2024-05-25T19:59:34.366577"} +{"lr": 1.331589857956061e-05, "step": 211, "loss": 1.689894676208496, "percent_done": 70.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5546.734376515309, "avg_wps": 3497.503824079731, "eta_in_seconds": 833.8381161791453, "at": "2024-05-25T19:59:40.275469"} +{"lr": 1.3042083538917017e-05, "step": 212, "loss": 1.5307470560073853, "percent_done": 70.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14050579071045, "wps": 5558.516162224653, "avg_wps": 3503.631620027942, "eta_in_seconds": 823.027165160989, "at": "2024-05-25T19:59:46.171786"} +{"lr": 1.2770329038951215e-05, "step": 213, "loss": 1.718467354774475, "percent_done": 71.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5557.865425033959, "avg_wps": 3509.7218675417203, "eta_in_seconds": 812.2626543045044, "at": "2024-05-25T19:59:52.068652"} +{"lr": 1.2500668100066407e-05, "step": 214, "loss": 1.1245841979980469, "percent_done": 71.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5558.5031235070055, "avg_wps": 3515.777302208401, "eta_in_seconds": 801.5433737028425, "at": "2024-05-25T19:59:57.965048"} +{"lr": 1.2233133488280923e-05, "step": 215, "loss": 1.0817248821258545, "percent_done": 71.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13904094696045, "wps": 5546.864438750632, "avg_wps": 3521.7752707436694, "eta_in_seconds": 790.873859311259, "at": "2024-05-25T20:00:03.873599"} +{"lr": 1.1967757711246922e-05, "step": 216, "loss": 1.1685675382614136, "percent_done": 72.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.139191150665283, "wps": 5546.362803735187, "avg_wps": 3527.7369791444125, "eta_in_seconds": 780.2486455970339, "at": "2024-05-25T20:00:09.782854"} +{"lr": 1.1704573014300402e-05, "step": 217, "loss": 1.3264338970184326, "percent_done": 72.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.139691829681396, "wps": 5559.338174519326, "avg_wps": 3533.68789516688, "eta_in_seconds": 769.6616341584289, "at": "2024-05-25T20:00:15.678284"} +{"lr": 1.1443611376543122e-05, "step": 218, "loss": 1.804037094116211, "percent_done": 72.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074945449829, "wps": 5545.649120751296, "avg_wps": 3539.5785323951377, "eta_in_seconds": 759.1231485353698, "at": "2024-05-25T20:00:21.588139"} +{"lr": 1.1184904506956906e-05, "step": 219, "loss": 1.2220178842544556, "percent_done": 73.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.140678882598877, "wps": 5547.759369594713, "avg_wps": 3545.438713944786, "eta_in_seconds": 748.626112069169, "at": "2024-05-25T20:00:27.495963"} +{"lr": 1.092848384055075e-05, "step": 220, "loss": 1.7789349555969238, "percent_done": 73.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026117324829, "wps": 5549.491613275015, "avg_wps": 3551.268018570465, "eta_in_seconds": 738.170137058605, "at": "2024-05-25T20:00:33.401735"} +{"lr": 1.0674380534541152e-05, "step": 221, "loss": 1.7085169553756714, "percent_done": 73.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5551.72498716578, "avg_wps": 3557.067659706891, "eta_in_seconds": 727.7545010806209, "at": "2024-05-25T20:00:39.305299"} +{"lr": 1.0422625464566322e-05, "step": 222, "loss": 1.4789329767227173, "percent_done": 74.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5555.1674473762705, "avg_wps": 3562.840152282426, "eta_in_seconds": 717.3782406046583, "at": "2024-05-25T20:00:45.205179"} +{"lr": 1.0173249220934514e-05, "step": 223, "loss": 1.0271649360656738, "percent_done": 74.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5546.966075104167, "avg_wps": 3568.5641884781217, "eta_in_seconds": 707.0451494599671, "at": "2024-05-25T20:00:51.113621"} +{"lr": 9.926282104907025e-06, "step": 224, "loss": 1.5872251987457275, "percent_done": 74.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026117324829, "wps": 5545.954802545316, "avg_wps": 3574.253418135587, "eta_in_seconds": 696.7519391221659, "at": "2024-05-25T20:00:57.023323"} +{"lr": 9.681754125016368e-06, "step": 225, "loss": 1.3932406902313232, "percent_done": 75.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14050579071045, "wps": 5546.735048077451, "avg_wps": 3579.911448998197, "eta_in_seconds": 686.4974273840586, "at": "2024-05-25T20:01:02.932012"} +{"lr": 9.439694993420004e-06, "step": 226, "loss": 1.4929049015045166, "percent_done": 75.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.140326023101807, "wps": 5544.103325704755, "avg_wps": 3585.532244543553, "eta_in_seconds": 676.2823019344196, "at": "2024-05-25T20:01:08.843763"} +{"lr": 9.200134122290056e-06, "step": 227, "loss": 1.419893741607666, "percent_done": 75.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5553.744932058036, "avg_wps": 3591.138752274632, "eta_in_seconds": 666.101803636761, "at": "2024-05-25T20:01:14.745031"} +{"lr": 8.963100620239454e-06, "step": 228, "loss": 1.7396320104599, "percent_done": 76.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074945449829, "wps": 5535.069526463625, "avg_wps": 3596.678940751907, "eta_in_seconds": 655.9651386361373, "at": "2024-05-25T20:01:20.666295"} +{"lr": 8.728623288785071e-06, "step": 229, "loss": 1.252681016921997, "percent_done": 76.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13931369781494, "wps": 5556.916228930842, "avg_wps": 3602.227886746879, "eta_in_seconds": 645.858083704153, "at": "2024-05-25T20:01:26.564325"} +{"lr": 8.496730618848046e-06, "step": 230, "loss": 1.4553861618041992, "percent_done": 76.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 1782.2634707316693, "avg_wps": 3586.305417195868, "eta_in_seconds": 639.5885830029198, "at": "2024-05-25T20:01:44.951028"} +{"lr": 8.267450787291907e-06, "step": 231, "loss": 1.7006911039352417, "percent_done": 77.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5596.349147252656, "avg_wps": 3591.890270695421, "eta_in_seconds": 629.4713450592833, "at": "2024-05-25T20:01:50.807497"} +{"lr": 8.040811653498885e-06, "step": 232, "loss": 1.404977798461914, "percent_done": 77.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5586.878924371278, "avg_wps": 3597.4272794356607, "eta_in_seconds": 619.3937575159403, "at": "2024-05-25T20:01:56.673840"} +{"lr": 7.816840755984746e-06, "step": 233, "loss": 1.58649742603302, "percent_done": 77.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5593.746867514532, "avg_wps": 3602.9458814666423, "eta_in_seconds": 609.3502573250701, "at": "2024-05-25T20:02:02.532985"} +{"lr": 7.59556530905263e-06, "step": 234, "loss": 1.684566855430603, "percent_done": 78.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.141377925872803, "wps": 5580.381717906633, "avg_wps": 3608.410231877479, "eta_in_seconds": 599.3464880723219, "at": "2024-05-25T20:02:08.406143"} +{"lr": 7.377012199486289e-06, "step": 235, "loss": 1.4991753101348877, "percent_done": 78.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5560.344211230606, "avg_wps": 3613.808578033969, "eta_in_seconds": 589.3837357480475, "at": "2024-05-25T20:02:14.300513"} +{"lr": 7.161207983283153e-06, "step": 236, "loss": 1.6088043451309204, "percent_done": 78.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.139200687408447, "wps": 5560.959978222105, "avg_wps": 3619.178252064031, "eta_in_seconds": 579.45529452825, "at": "2024-05-25T20:02:20.194217"} +{"lr": 6.948178882427538e-06, "step": 237, "loss": 1.529589056968689, "percent_done": 79.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.139482975006104, "wps": 5556.713802680577, "avg_wps": 3624.5107746039716, "eta_in_seconds": 569.5621087581296, "at": "2024-05-25T20:02:26.092432"} +{"lr": 6.7379507817044246e-06, "step": 238, "loss": 1.2549418210983276, "percent_done": 79.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5553.26381674801, "avg_wps": 3629.8078358577736, "eta_in_seconds": 559.7034586597891, "at": "2024-05-25T20:02:31.994328"} +{"lr": 6.530549225554315e-06, "step": 239, "loss": 1.5565565824508667, "percent_done": 79.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5555.7007697153795, "avg_wps": 3635.0802485283916, "eta_in_seconds": 549.8772690944592, "at": "2024-05-25T20:02:37.893645"} +{"lr": 6.325999414969323e-06, "step": 240, "loss": 1.9406781196594238, "percent_done": 80.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5546.354298435116, "avg_wps": 3640.30712382121, "eta_in_seconds": 540.0862985253334, "at": "2024-05-25T20:02:43.802930"} +{"lr": 6.124326204431042e-06, "step": 241, "loss": 1.0665113925933838, "percent_done": 80.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5553.128069344811, "avg_wps": 3645.5176164738386, "eta_in_seconds": 530.3257872801104, "at": "2024-05-25T20:02:49.704939"} +{"lr": 5.925554098890568e-06, "step": 242, "loss": 1.1805481910705566, "percent_done": 80.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13930654525757, "wps": 5555.999699559778, "avg_wps": 3650.7049255016454, "eta_in_seconds": 520.5964433673985, "at": "2024-05-25T20:02:55.603886"} +{"lr": 5.7297072507909045e-06, "step": 243, "loss": 1.8694003820419312, "percent_done": 81.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5551.771857278952, "avg_wps": 3655.8566030920956, "eta_in_seconds": 510.89968857647466, "at": "2024-05-25T20:03:01.507360"} +{"lr": 5.536809457132242e-06, "step": 244, "loss": 1.2083914279937744, "percent_done": 81.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879632949829, "wps": 5548.257225687174, "avg_wps": 3660.9741676849917, "eta_in_seconds": 501.2348943069333, "at": "2024-05-25T20:03:07.414577"} +{"lr": 5.346884156580474e-06, "step": 245, "loss": 1.4251652956008911, "percent_done": 81.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001703262329, "wps": 5546.042082448128, "avg_wps": 3666.0601792835423, "eta_in_seconds": 491.60131363479456, "at": "2024-05-25T20:03:13.324130"} +{"lr": 5.159954426619136e-06, "step": 246, "loss": 1.5258452892303467, "percent_done": 82.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.139216423034668, "wps": 5549.477272407921, "avg_wps": 3671.1249348208994, "eta_in_seconds": 481.99721649797954, "at": "2024-05-25T20:03:19.230036"} +{"lr": 4.976042980745373e-06, "step": 247, "loss": 1.6137484312057495, "percent_done": 82.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5549.085616130843, "avg_wps": 3676.161827965701, "eta_in_seconds": 472.4231634168973, "at": "2024-05-25T20:03:25.136340"} +{"lr": 4.795172165709995e-06, "step": 248, "loss": 1.3485848903656006, "percent_done": 82.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952875137329, "wps": 5556.97958845692, "avg_wps": 3681.185762463588, "eta_in_seconds": 462.87693964665937, "at": "2024-05-25T20:03:31.034313"} +{"lr": 4.617363958802224e-06, "step": 249, "loss": 1.6160105466842651, "percent_done": 83.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5564.703183015024, "avg_wps": 3686.196559123569, "eta_in_seconds": 453.35835276167074, "at": "2024-05-25T20:03:36.924012"} +{"lr": 4.442639965179252e-06, "step": 250, "loss": 1.431312918663025, "percent_done": 83.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5532.419017593661, "avg_wps": 3691.1236156567375, "eta_in_seconds": 443.8756786823273, "at": "2024-05-25T20:03:42.848113"} +{"lr": 4.271021415240995e-06, "step": 251, "loss": 1.100666880607605, "percent_done": 83.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5556.306298891694, "avg_wps": 3696.0667370816636, "eta_in_seconds": 434.4163983542606, "at": "2024-05-25T20:03:48.746759"} +{"lr": 4.102529162050497e-06, "step": 252, "loss": 1.935880184173584, "percent_done": 84.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5548.219821787917, "avg_wps": 3700.969469391775, "eta_in_seconds": 424.98702380770726, "at": "2024-05-25T20:03:54.653988"} +{"lr": 3.937183678800066e-06, "step": 253, "loss": 1.427884578704834, "percent_done": 84.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.1408052444458, "wps": 5549.872569691327, "avg_wps": 3705.8492282851994, "eta_in_seconds": 415.5851749836692, "at": "2024-05-25T20:04:00.559361"} +{"lr": 3.775005056323612e-06, "step": 254, "loss": 1.4423906803131104, "percent_done": 84.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5547.009282876098, "avg_wps": 3710.698254976525, "eta_in_seconds": 406.21141802044366, "at": "2024-05-25T20:04:06.467920"} +{"lr": 3.6160130006554755e-06, "step": 255, "loss": 1.6522537469863892, "percent_done": 85.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5548.4505245332075, "avg_wps": 3715.5243423520897, "eta_in_seconds": 396.86457795255325, "at": "2024-05-25T20:04:12.374946"} +{"lr": 3.4602268306359405e-06, "step": 256, "loss": 1.3131394386291504, "percent_done": 85.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5561.882646539059, "avg_wps": 3720.3486816311442, "eta_in_seconds": 387.5421696677804, "at": "2024-05-25T20:04:18.267665"} +{"lr": 3.3076654755638867e-06, "step": 257, "loss": 1.35945463180542, "percent_done": 85.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14069938659668, "wps": 5556.845007358711, "avg_wps": 3725.139074678171, "eta_in_seconds": 378.24735446198906, "at": "2024-05-25T20:04:24.165723"} +{"lr": 3.158347472896674e-06, "step": 258, "loss": 1.5388786792755127, "percent_done": 86.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5546.140779186253, "avg_wps": 3729.8858130333006, "eta_in_seconds": 368.98073265164396, "at": "2024-05-25T20:04:30.075179"} +{"lr": 3.012290965997729e-06, "step": 259, "loss": 1.4934773445129395, "percent_done": 86.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5555.486305686656, "avg_wps": 3734.6242030674875, "eta_in_seconds": 359.738470847082, "at": "2024-05-25T20:04:35.974718"} +{"lr": 2.8695137019319605e-06, "step": 260, "loss": 1.8609613180160522, "percent_done": 86.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.141068935394287, "wps": 5559.494915070221, "avg_wps": 3739.345039533169, "eta_in_seconds": 350.52127742767334, "at": "2024-05-25T20:04:41.869977"} +{"lr": 2.7300330293093305e-06, "step": 261, "loss": 1.782885193824768, "percent_done": 87.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5550.138149660146, "avg_wps": 3744.0252275365783, "eta_in_seconds": 341.33103340247584, "at": "2024-05-25T20:04:47.775204"} +{"lr": 2.5938658961768874e-06, "step": 262, "loss": 1.3098511695861816, "percent_done": 87.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952875137329, "wps": 5544.886629604724, "avg_wps": 3748.6721324433747, "eta_in_seconds": 332.1666862309434, "at": "2024-05-25T20:04:53.686007"} +{"lr": 2.461028847959424e-06, "step": 263, "loss": 1.42243230342865, "percent_done": 87.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5552.670391476748, "avg_wps": 3753.3086590036955, "eta_in_seconds": 323.0259246309447, "at": "2024-05-25T20:04:59.588536"} +{"lr": 2.3315380254490547e-06, "step": 264, "loss": 1.6030670404434204, "percent_done": 88.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5550.543404194706, "avg_wps": 3757.917721991215, "eta_in_seconds": 313.9100127436898, "at": "2024-05-25T20:05:05.493283"} +{"lr": 2.2054091628440125e-06, "step": 265, "loss": 1.1693111658096313, "percent_done": 88.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5552.938482839516, "avg_wps": 3762.507356448951, "eta_in_seconds": 304.8180086702671, "at": "2024-05-25T20:05:11.395513"} +{"lr": 2.082657585836788e-06, "step": 266, "loss": 1.044421672821045, "percent_done": 88.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5543.642885680089, "avg_wps": 3767.057470999801, "eta_in_seconds": 295.75126171470583, "at": "2024-05-25T20:05:17.307512"} +{"lr": 1.9632982097519294e-06, "step": 267, "loss": 1.4933841228485107, "percent_done": 89.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5543.912565895474, "avg_wps": 3771.5848647029225, "eta_in_seconds": 286.70811841461096, "at": "2024-05-25T20:05:23.219370"} +{"lr": 1.8473455377337344e-06, "step": 268, "loss": 1.7525793313980103, "percent_done": 89.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.139050006866455, "wps": 5540.596160108646, "avg_wps": 3776.0835012234875, "eta_in_seconds": 277.68877453590505, "at": "2024-05-25T20:05:29.134737"} +{"lr": 1.7348136589839818e-06, "step": 269, "loss": 1.6476473808288574, "percent_done": 89.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5548.377951892565, "avg_wps": 3780.5727653899426, "eta_in_seconds": 268.69156158014744, "at": "2024-05-25T20:05:35.041771"} +{"lr": 1.625716247049965e-06, "step": 270, "loss": 1.569866418838501, "percent_done": 90.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879632949829, "wps": 5542.068932991183, "avg_wps": 3785.0284574071684, "eta_in_seconds": 259.7179944780138, "at": "2024-05-25T20:05:40.955603"} +{"lr": 1.5200665581630721e-06, "step": 271, "loss": 1.3271491527557373, "percent_done": 90.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5557.273263000243, "avg_wps": 3789.4878240893577, "eta_in_seconds": 250.7652865274366, "at": "2024-05-25T20:05:46.853195"} +{"lr": 1.4178774296280323e-06, "step": 272, "loss": 1.4826464653015137, "percent_done": 90.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5554.670146391165, "avg_wps": 3793.9203430231014, "eta_in_seconds": 241.8353357595556, "at": "2024-05-25T20:05:52.753550"} +{"lr": 1.319161278263055e-06, "step": 273, "loss": 1.2396349906921387, "percent_done": 91.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5547.749068522851, "avg_wps": 3798.318787706219, "eta_in_seconds": 232.9283163023519, "at": "2024-05-25T20:05:58.661269"} +{"lr": 1.2239300988911303e-06, "step": 274, "loss": 1.8445279598236084, "percent_done": 91.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5547.267424158582, "avg_wps": 3802.6943998052316, "eta_in_seconds": 224.04324682089532, "at": "2024-05-25T20:06:04.569488"} +{"lr": 1.1321954628825247e-06, "step": 275, "loss": 1.9847421646118164, "percent_done": 91.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5543.669271143517, "avg_wps": 3807.0420056576686, "eta_in_seconds": 215.1801841909235, "at": "2024-05-25T20:06:10.481571"} +{"lr": 1.0439685167487763e-06, "step": 276, "loss": 1.4393119812011719, "percent_done": 92.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5548.7827253903315, "avg_wps": 3811.3767009941253, "eta_in_seconds": 206.33804047625998, "at": "2024-05-25T20:06:16.388112"} +{"lr": 9.592599807882922e-07, "step": 277, "loss": 1.5156468152999878, "percent_done": 92.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952875137329, "wps": 5535.420860398796, "avg_wps": 3815.667008661193, "eta_in_seconds": 197.5182840350733, "at": "2024-05-25T20:06:22.309037"} +{"lr": 8.780801477837637e-07, "step": 278, "loss": 1.3248686790466309, "percent_done": 92.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.1411771774292, "wps": 5545.85655999245, "avg_wps": 3819.9538595110757, "eta_in_seconds": 188.7185098335897, "at": "2024-05-25T20:06:28.218807"} +{"lr": 8.004388817514974e-07, "step": 279, "loss": 1.8016791343688965, "percent_done": 93.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5549.118774817597, "avg_wps": 3824.2250765085532, "eta_in_seconds": 179.93919976808692, "at": "2024-05-25T20:06:34.125087"} +{"lr": 7.263456167428465e-07, "step": 280, "loss": 1.2042957544326782, "percent_done": 93.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14050579071045, "wps": 5553.630928916902, "avg_wps": 3828.4829091857796, "eta_in_seconds": 171.18007721219743, "at": "2024-05-25T20:06:40.026564"} +{"lr": 6.558093556979173e-07, "step": 281, "loss": 1.3349308967590332, "percent_done": 93.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.139925479888916, "wps": 5549.048201061506, "avg_wps": 3832.712053773297, "eta_in_seconds": 162.44163173882563, "at": "2024-05-25T20:06:45.932901"} +{"lr": 5.888386693516242e-07, "step": 282, "loss": 1.258479356765747, "percent_done": 94.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13757610321045, "wps": 5546.529109975467, "avg_wps": 3836.9161860137633, "eta_in_seconds": 153.72345170061638, "at": "2024-05-25T20:06:51.841916"} +{"lr": 5.25441695192271e-07, "step": 283, "loss": 2.0836853981018066, "percent_done": 94.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14001750946045, "wps": 5549.132217641336, "avg_wps": 3841.104151886971, "eta_in_seconds": 145.02496625256623, "at": "2024-05-25T20:06:57.748212"} +{"lr": 4.656261364727923e-07, "step": 284, "loss": 1.5532150268554688, "percent_done": 94.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.141345500946045, "wps": 5554.43847719448, "avg_wps": 3845.280643914955, "eta_in_seconds": 136.34583494696818, "at": "2024-05-25T20:07:03.648823"} +{"lr": 4.0939926127473865e-07, "step": 285, "loss": 1.5791882276535034, "percent_done": 95.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5534.097794340826, "avg_wps": 3849.402418681457, "eta_in_seconds": 127.68735157816035, "at": "2024-05-25T20:07:09.571112"} +{"lr": 3.5676790162514096e-07, "step": 286, "loss": 1.4037915468215942, "percent_done": 95.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5566.4622579523275, "avg_wps": 3853.558672908996, "eta_in_seconds": 119.04632547185136, "at": "2024-05-25T20:07:15.459019"} +{"lr": 3.077384526663671e-07, "step": 287, "loss": 1.6318409442901611, "percent_done": 95.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5552.7899637567, "avg_wps": 3857.6719185237143, "eta_in_seconds": 110.42514993421707, "at": "2024-05-25T20:07:21.361387"} +{"lr": 2.623168718790634e-07, "step": 288, "loss": 1.6726363897323608, "percent_done": 96.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14067506790161, "wps": 5546.801981253329, "avg_wps": 3861.755231654426, "eta_in_seconds": 101.82312871019046, "at": "2024-05-25T20:07:27.270131"} +{"lr": 2.2050867835827008e-07, "step": 289, "loss": 1.9459331035614014, "percent_done": 96.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14051628112793, "wps": 5548.215118339275, "avg_wps": 3865.8212248520517, "eta_in_seconds": 93.23969708759479, "at": "2024-05-25T20:07:33.177362"} +{"lr": 1.8231895214279363e-07, "step": 290, "loss": 1.794161319732666, "percent_done": 96.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879632949829, "wps": 5547.06771518238, "avg_wps": 3869.8657340056116, "eta_in_seconds": 84.67477233656523, "at": "2024-05-25T20:07:39.085841"} +{"lr": 1.477523335979629e-07, "step": 291, "loss": 1.6427291631698608, "percent_done": 97.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074993133545, "wps": 5555.654956113266, "avg_wps": 3873.905200474016, "eta_in_seconds": 76.12783089372302, "at": "2024-05-25T20:07:44.985156"} +{"lr": 1.1681302285176604e-07, "step": 292, "loss": 1.3072571754455566, "percent_done": 97.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14074945449829, "wps": 5545.337655372716, "avg_wps": 3877.90810744921, "eta_in_seconds": 67.59933261348776, "at": "2024-05-25T20:07:50.895457"} +{"lr": 8.950477928451045e-08, "step": 293, "loss": 1.4584952592849731, "percent_done": 97.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5553.325522307091, "avg_wps": 3881.90522758884, "eta_in_seconds": 59.088511066632066, "at": "2024-05-25T20:07:56.797289"} +{"lr": 6.58309210720302e-08, "step": 294, "loss": 1.9135187864303589, "percent_done": 98.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13879680633545, "wps": 5548.705887805556, "avg_wps": 3885.8756208362624, "eta_in_seconds": 50.595546328291604, "at": "2024-05-25T20:08:02.704010"} +{"lr": 4.579432478248678e-08, "step": 295, "loss": 1.5796616077423096, "percent_done": 98.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.138890266418457, "wps": 5534.935558707954, "avg_wps": 3889.8041464688886, "eta_in_seconds": 42.120372602495095, "at": "2024-05-25T20:08:08.625417"} +{"lr": 2.9397425026856707e-08, "step": 296, "loss": 1.1797804832458496, "percent_done": 98.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.13952922821045, "wps": 5549.133785975015, "avg_wps": 3893.7376763503958, "eta_in_seconds": 33.662257423272, "at": "2024-05-25T20:08:14.531750"} +{"lr": 1.6642214163099443e-08, "step": 297, "loss": 1.4919604063034058, "percent_done": 99.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.139925479888916, "wps": 5536.0737109014835, "avg_wps": 3897.630855719781, "eta_in_seconds": 25.221475208648528, "at": "2024-05-25T20:08:20.451916"} +{"lr": 7.530242054078596e-09, "step": 298, "loss": 1.9425216913223267, "percent_done": 99.33333333333333, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5545.809565924517, "avg_wps": 3901.521818920173, "eta_in_seconds": 16.797547993243942, "at": "2024-05-25T20:08:26.361734"} +{"lr": 2.062615879216702e-09, "step": 299, "loss": 1.8535929918289185, "percent_done": 99.66666666666667, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.139925003051758, "wps": 5520.707126345623, "avg_wps": 3905.3526315623412, "eta_in_seconds": 8.390535526849753, "at": "2024-05-25T20:08:32.298415"} +{"lr": 2.4e-10, "step": 300, "loss": 1.5795124769210815, "percent_done": 100.0, "peak_allocated_mem": 40.3391375541687, "allocated_mem": 20.14026165008545, "wps": 5557.2905653761345, "avg_wps": 3909.2261012039853, "eta_in_seconds": 0.0, "at": "2024-05-25T20:08:38.195958"} diff --git a/runs/tb/events.out.tfevents.1716665197.scw-tender-archimedes.27183.0.train b/runs/tb/events.out.tfevents.1716665197.scw-tender-archimedes.27183.0.train new file mode 100644 index 0000000000000000000000000000000000000000..829d8092ad4b73223e250b463bc00489388f5652 --- /dev/null +++ b/runs/tb/events.out.tfevents.1716665197.scw-tender-archimedes.27183.0.train @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3255efbbd8a1edfc3651bf888f78e2b099be7ef1f3d5ad960eb32ccf2580d96b +size 128972 diff --git a/runs/tb/events.out.tfevents.1716665200.scw-tender-archimedes.27183.1.eval b/runs/tb/events.out.tfevents.1716665200.scw-tender-archimedes.27183.1.eval new file mode 100644 index 0000000000000000000000000000000000000000..da86e426c40a4a5b2616c3a3a0609be7f5ea51aa --- /dev/null +++ b/runs/tb/events.out.tfevents.1716665200.scw-tender-archimedes.27183.1.eval @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:bfef5c634bc18903eb5bae03fde7a1e6b2490d40611d3ec91c126d1f2cf71257 +size 88 diff --git a/runs/wandb/debug-internal.log b/runs/wandb/debug-internal.log new file mode 120000 index 0000000000000000000000000000000000000000..7dcd5819ecf4f47e29f971cd1a13b49e8e03c065 --- /dev/null +++ b/runs/wandb/debug-internal.log @@ -0,0 +1 @@ +run-20240525_192638-zf4t8z6a/logs/debug-internal.log \ No newline at end of file diff --git a/runs/wandb/debug.log b/runs/wandb/debug.log new file mode 120000 index 0000000000000000000000000000000000000000..cacc00e23f5a8800303552c508fe27ae9c2c6c89 --- /dev/null +++ b/runs/wandb/debug.log @@ -0,0 +1 @@ +run-20240525_192638-zf4t8z6a/logs/debug.log \ No newline at end of file diff --git a/runs/wandb/latest-run b/runs/wandb/latest-run new file mode 120000 index 0000000000000000000000000000000000000000..fe412e7ce1d69af5c04f620a8d07c7699e75730a --- /dev/null +++ b/runs/wandb/latest-run @@ -0,0 +1 @@ +run-20240525_192638-zf4t8z6a \ No newline at end of file diff --git a/runs/wandb/run-20240525_192638-zf4t8z6a/files/conda-environment.yaml b/runs/wandb/run-20240525_192638-zf4t8z6a/files/conda-environment.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b872d6a32156b541e625a9e137de272c9701a8f3 --- /dev/null +++ b/runs/wandb/run-20240525_192638-zf4t8z6a/files/conda-environment.yaml @@ -0,0 +1,92 @@ +name: chemistralpy310 +channels: + - defaults +dependencies: + - _libgcc_mutex=0.1=main + - _openmp_mutex=5.1=1_gnu + - bzip2=1.0.8=h5eee18b_6 + - ca-certificates=2024.3.11=h06a4308_0 + - ld_impl_linux-64=2.38=h1181459_1 + - libffi=3.4.4=h6a678d5_1 + - libgcc-ng=11.2.0=h1234567_1 + - libgomp=11.2.0=h1234567_1 + - libstdcxx-ng=11.2.0=h1234567_1 + - libuuid=1.41.5=h5eee18b_0 + - ncurses=6.4=h6a678d5_0 + - openssl=3.0.13=h7f8727e_2 + - pip=24.0=py310h06a4308_0 + - python=3.10.14=h955ad1f_1 + - readline=8.2=h5eee18b_0 + - setuptools=69.5.1=py310h06a4308_0 + - sqlite=3.45.3=h5eee18b_0 + - tk=8.6.14=h39e8969_0 + - tzdata=2024a=h04d1e81_0 + - wheel=0.43.0=py310h06a4308_0 + - xz=5.4.6=h5eee18b_1 + - zlib=1.2.13=h5eee18b_1 + - pip: + - absl-py==2.1.0 + - annotated-types==0.7.0 + - attrs==23.2.0 + - certifi==2024.2.2 + - charset-normalizer==3.3.2 + - click==8.1.7 + - docker-pycreds==0.4.0 + - docstring-parser==0.16 + - filelock==3.14.0 + - fire==0.6.0 + - fsspec==2024.5.0 + - gitdb==4.0.11 + - gitpython==3.1.43 + - grpcio==1.64.0 + - idna==3.7 + - jinja2==3.1.4 + - jsonschema==4.21.1 + - jsonschema-specifications==2023.12.1 + - markdown==3.6 + - markupsafe==2.1.5 + - mistral-common==1.1.0 + - mpmath==1.3.0 + - networkx==3.3 + - numpy==1.26.4 + - nvidia-cublas-cu12==12.1.3.1 + - nvidia-cuda-cupti-cu12==12.1.105 + - nvidia-cuda-nvrtc-cu12==12.1.105 + - nvidia-cuda-runtime-cu12==12.1.105 + - nvidia-cudnn-cu12==8.9.2.26 + - nvidia-cufft-cu12==11.0.2.54 + - nvidia-curand-cu12==10.3.2.106 + - nvidia-cusolver-cu12==11.4.5.107 + - nvidia-cusparse-cu12==12.1.0.106 + - nvidia-nccl-cu12==2.19.3 + - nvidia-nvjitlink-cu12==12.5.40 + - nvidia-nvtx-cu12==12.1.105 + - platformdirs==4.2.2 + - protobuf==4.25.3 + - psutil==5.9.8 + - pydantic==2.6.1 + - pydantic-core==2.16.2 + - pyyaml==6.0.1 + - referencing==0.35.1 + - requests==2.32.2 + - rpds-py==0.18.1 + - safetensors==0.4.3 + - sentencepiece==0.1.99 + - sentry-sdk==2.3.1 + - setproctitle==1.3.3 + - simple-parsing==0.1.5 + - six==1.16.0 + - smmap==5.0.1 + - sympy==1.12 + - tensorboard==2.16.2 + - tensorboard-data-server==0.7.2 + - termcolor==2.4.0 + - torch==2.2.0 + - tqdm==4.66.4 + - triton==2.2.0 + - typing-extensions==4.12.0 + - urllib3==2.2.1 + - wandb==0.17.0 + - werkzeug==3.0.3 + - xformers==0.0.24 +prefix: /root/miniconda/envs/chemistralpy310 diff --git a/runs/wandb/run-20240525_192638-zf4t8z6a/files/config.yaml b/runs/wandb/run-20240525_192638-zf4t8z6a/files/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..4ed638caa1f5a1ad11f16b375d3ac5cea9743e07 --- /dev/null +++ b/runs/wandb/run-20240525_192638-zf4t8z6a/files/config.yaml @@ -0,0 +1,115 @@ +wandb_version: 1 + +data: + desc: null + value: + data: '' + shuffle: false + instruct_data: /root/data/mol_instructions_train.jsonl + eval_instruct_data: '' + instruct: + shuffle: true + dynamic_chunk_fn_call: true +model_id_or_path: + desc: null + value: /root/mistral_models/7B-v0.3 +run_dir: + desc: null + value: /root/mistral-finetune/runs +optim: + desc: null + value: + lr: 6.0e-05 + weight_decay: 0.1 + pct_start: 0.05 +seed: + desc: null + value: 0 +num_microbatches: + desc: null + value: 1 +seq_len: + desc: null + value: 32768 +batch_size: + desc: null + value: 1 +max_norm: + desc: null + value: 1.0 +max_steps: + desc: null + value: 300 +log_freq: + desc: null + value: 1 +ckpt_freq: + desc: null + value: 100 +ckpt_only_lora: + desc: null + value: true +no_ckpt: + desc: null + value: false +num_ckpt_keep: + desc: null + value: 3 +eval_freq: + desc: null + value: 100 +no_eval: + desc: null + value: true +checkpoint: + desc: null + value: true +world_size: + desc: null + value: 1 +wandb: + desc: null + value: + project: CHEMISTral7b-ft + offline: false + key: aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df + run_name: run0 +mlflow: + desc: null + value: + tracking_uri: null + experiment_name: null +lora: + desc: null + value: + enable: true + rank: 64 + dropout: 0.0 + scaling: 2.0 +_wandb: + desc: null + value: + python_version: 3.10.14 + cli_version: 0.17.0 + framework: torch + is_jupyter_run: false + is_kaggle_kernel: false + start_time: 1716665198 + t: + 1: + - 1 + - 55 + 2: + - 1 + - 55 + 3: + - 2 + - 13 + - 16 + - 23 + - 61 + 4: 3.10.14 + 5: 0.17.0 + 8: + - 5 + 13: linux-x86_64 diff --git a/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log b/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log new file mode 100644 index 0000000000000000000000000000000000000000..92d21b685a70ea32c1d124cac629e6dc02d40341 --- /dev/null +++ b/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log @@ -0,0 +1,327 @@ + +wandb: WARNING Calling wandb.login() after wandb.init() has no effect. +2024-05-25 19:26:40 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Reloading model from /root/mistral_models/7B-v0.3/consolidated.safetensors ... +2024-05-25 19:26:40 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Converting model to dtype torch.bfloat16 ... +2024-05-25 19:26:40 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Loaded model on cpu! +2024-05-25 19:26:40 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Initializing lora layers ... +2024-05-25 19:26:40 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Finished initialization! +2024-05-25 19:26:40 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Sharding model over 1 GPUs ... +2024-05-25 19:26:42 (UTC) - 0:00:06 - finetune.wrapped_model - INFO - Model sharded! +2024-05-25 19:26:42 (UTC) - 0:00:06 - finetune.wrapped_model - INFO - 167,772,160 out of 7,415,795,712 parameter are finetuned (2.26%). +2024-05-25 19:26:42 (UTC) - 0:00:06 - dataset - INFO - Loading /root/data/mol_instructions_train.jsonl ... +2024-05-25 19:38:44 (UTC) - 0:12:08 - dataset - INFO - /root/data/mol_instructions_train.jsonl loaded and tokenized. +2024-05-25 19:38:44 (UTC) - 0:12:08 - dataset - INFO - Shuffling /root/data/mol_instructions_train.jsonl ... +2024-05-25 19:38:50 (UTC) - 0:12:14 - train - INFO - step: 000001 - done (%): 0.3 - loss: 2.053 - lr: 2.4e-06 - peak_alloc_mem (GB): 39.1 - alloc_mem (GB): 20.1 - words_per_second: 45.0 - avg_words_per_second: 45.0 - ETA: >2024-05-28 08:07:33 +2024-05-25 19:38:56 (UTC) - 0:12:20 - train - INFO - step: 000002 - done (%): 0.7 - loss: 2.260 - lr: 3.1e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5705.1 - avg_words_per_second: 89.3 - ETA: >2024-05-27 02:01:29 +2024-05-25 19:39:02 (UTC) - 0:12:26 - train - INFO - step: 000003 - done (%): 1.0 - loss: 2.245 - lr: 5.3e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5654.6 - avg_words_per_second: 132.9 - ETA: >2024-05-26 15:59:33 +2024-05-25 19:39:07 (UTC) - 0:12:32 - train - INFO - step: 000004 - done (%): 1.3 - loss: 2.135 - lr: 8.7e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5650.9 - avg_words_per_second: 175.8 - ETA: >2024-05-26 10:58:35 +2024-05-25 19:39:13 (UTC) - 0:12:38 - train - INFO - step: 000005 - done (%): 1.7 - loss: 2.017 - lr: 1.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5630.6 - avg_words_per_second: 218.1 - ETA: >2024-05-26 07:58:02 +2024-05-25 19:39:19 (UTC) - 0:12:43 - train - INFO - step: 000006 - done (%): 2.0 - loss: 2.257 - lr: 1.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5619.5 - avg_words_per_second: 259.7 - ETA: >2024-05-26 05:57:40 +2024-05-25 19:39:25 (UTC) - 0:12:49 - train - INFO - step: 000007 - done (%): 2.3 - loss: 2.577 - lr: 2.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5600.4 - avg_words_per_second: 300.6 - ETA: >2024-05-26 04:31:42 +2024-05-25 19:39:31 (UTC) - 0:12:55 - train - INFO - step: 000008 - done (%): 2.7 - loss: 1.741 - lr: 3.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5601.7 - avg_words_per_second: 341.0 - ETA: >2024-05-26 03:27:14 +2024-05-25 19:39:37 (UTC) - 0:13:01 - train - INFO - step: 000009 - done (%): 3.0 - loss: 2.051 - lr: 3.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5599.6 - avg_words_per_second: 380.7 - ETA: >2024-05-26 02:37:06 +2024-05-25 19:39:43 (UTC) - 0:13:07 - train - INFO - step: 000010 - done (%): 3.3 - loss: 1.708 - lr: 4.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5582.4 - avg_words_per_second: 419.8 - ETA: >2024-05-26 01:56:59 +2024-05-25 19:39:48 (UTC) - 0:13:13 - train - INFO - step: 000011 - done (%): 3.7 - loss: 1.980 - lr: 4.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5565.0 - avg_words_per_second: 458.3 - ETA: >2024-05-26 01:24:11 +2024-05-25 19:39:54 (UTC) - 0:13:19 - train - INFO - step: 000012 - done (%): 4.0 - loss: 1.337 - lr: 5.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.8 - avg_words_per_second: 496.3 - ETA: >2024-05-26 00:56:51 +2024-05-25 19:40:00 (UTC) - 0:13:24 - train - INFO - step: 000013 - done (%): 4.3 - loss: 1.739 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5574.7 - avg_words_per_second: 533.7 - ETA: >2024-05-26 00:33:43 +2024-05-25 19:40:06 (UTC) - 0:13:30 - train - INFO - step: 000014 - done (%): 4.7 - loss: 2.066 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5574.7 - avg_words_per_second: 570.5 - ETA: >2024-05-26 00:13:53 +2024-05-25 19:40:12 (UTC) - 0:13:36 - train - INFO - step: 000015 - done (%): 5.0 - loss: 1.873 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5559.9 - avg_words_per_second: 606.8 - ETA: >2024-05-25 23:56:42 +2024-05-25 19:40:18 (UTC) - 0:13:42 - train - INFO - step: 000016 - done (%): 5.3 - loss: 1.305 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5558.8 - avg_words_per_second: 642.6 - ETA: >2024-05-25 23:41:40 +2024-05-25 19:40:24 (UTC) - 0:13:48 - train - INFO - step: 000017 - done (%): 5.7 - loss: 2.024 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.0 - avg_words_per_second: 677.8 - ETA: >2024-05-25 23:28:25 +2024-05-25 19:40:30 (UTC) - 0:13:54 - train - INFO - step: 000018 - done (%): 6.0 - loss: 1.961 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.6 - avg_words_per_second: 712.6 - ETA: >2024-05-25 23:16:37 +2024-05-25 19:40:36 (UTC) - 0:14:00 - train - INFO - step: 000019 - done (%): 6.3 - loss: 1.837 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5562.2 - avg_words_per_second: 746.9 - ETA: >2024-05-25 23:06:04 +2024-05-25 19:40:41 (UTC) - 0:14:06 - train - INFO - step: 000020 - done (%): 6.7 - loss: 1.985 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.8 - avg_words_per_second: 780.7 - ETA: >2024-05-25 22:56:35 +2024-05-25 19:40:47 (UTC) - 0:14:12 - train - INFO - step: 000021 - done (%): 7.0 - loss: 2.009 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5559.2 - avg_words_per_second: 814.0 - ETA: >2024-05-25 22:47:59 +2024-05-25 19:40:53 (UTC) - 0:14:17 - train - INFO - step: 000022 - done (%): 7.3 - loss: 1.645 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.9 - avg_words_per_second: 846.8 - ETA: >2024-05-25 22:40:11 +2024-05-25 19:40:59 (UTC) - 0:14:23 - train - INFO - step: 000023 - done (%): 7.7 - loss: 1.644 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.4 - avg_words_per_second: 879.2 - ETA: >2024-05-25 22:33:03 +2024-05-25 19:41:05 (UTC) - 0:14:29 - train - INFO - step: 000024 - done (%): 8.0 - loss: 1.548 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.0 - avg_words_per_second: 911.2 - ETA: >2024-05-25 22:26:31 +2024-05-25 19:41:11 (UTC) - 0:14:35 - train - INFO - step: 000025 - done (%): 8.3 - loss: 1.812 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5547.9 - avg_words_per_second: 942.7 - ETA: >2024-05-25 22:20:30 +2024-05-25 19:41:17 (UTC) - 0:14:41 - train - INFO - step: 000026 - done (%): 8.7 - loss: 2.147 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.4 - avg_words_per_second: 973.8 - ETA: >2024-05-25 22:14:57 +2024-05-25 19:41:23 (UTC) - 0:14:47 - train - INFO - step: 000027 - done (%): 9.0 - loss: 2.011 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.8 - avg_words_per_second: 1004.4 - ETA: >2024-05-25 22:09:49 +2024-05-25 19:41:29 (UTC) - 0:14:53 - train - INFO - step: 000028 - done (%): 9.3 - loss: 1.763 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.5 - avg_words_per_second: 1034.7 - ETA: >2024-05-25 22:05:03 +2024-05-25 19:41:35 (UTC) - 0:14:59 - train - INFO - step: 000029 - done (%): 9.7 - loss: 1.593 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.2 - avg_words_per_second: 1064.6 - ETA: >2024-05-25 22:00:36 +2024-05-25 19:41:41 (UTC) - 0:15:05 - train - INFO - step: 000030 - done (%): 10.0 - loss: 1.348 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5543.6 - avg_words_per_second: 1094.0 - ETA: >2024-05-25 21:56:27 +2024-05-25 19:41:46 (UTC) - 0:15:11 - train - INFO - step: 000031 - done (%): 10.3 - loss: 1.891 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.0 - avg_words_per_second: 1123.1 - ETA: >2024-05-25 21:52:35 +2024-05-25 19:41:52 (UTC) - 0:15:17 - train - INFO - step: 000032 - done (%): 10.7 - loss: 1.865 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.6 - avg_words_per_second: 1151.8 - ETA: >2024-05-25 21:48:56 +2024-05-25 19:41:58 (UTC) - 0:15:22 - train - INFO - step: 000033 - done (%): 11.0 - loss: 1.782 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.2 - avg_words_per_second: 1180.2 - ETA: >2024-05-25 21:45:32 +2024-05-25 19:42:04 (UTC) - 0:15:28 - train - INFO - step: 000034 - done (%): 11.3 - loss: 1.531 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5544.7 - avg_words_per_second: 1208.2 - ETA: >2024-05-25 21:42:19 +2024-05-25 19:42:10 (UTC) - 0:15:34 - train - INFO - step: 000035 - done (%): 11.7 - loss: 1.924 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.1 - avg_words_per_second: 1235.8 - ETA: >2024-05-25 21:39:17 +2024-05-25 19:42:16 (UTC) - 0:15:40 - train - INFO - step: 000036 - done (%): 12.0 - loss: 1.983 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5560.2 - avg_words_per_second: 1263.1 - ETA: >2024-05-25 21:36:25 +2024-05-25 19:42:22 (UTC) - 0:15:46 - train - INFO - step: 000037 - done (%): 12.3 - loss: 1.230 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.6 - avg_words_per_second: 1290.0 - ETA: >2024-05-25 21:33:42 +2024-05-25 19:42:28 (UTC) - 0:15:52 - train - INFO - step: 000038 - done (%): 12.7 - loss: 1.590 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5550.5 - avg_words_per_second: 1316.6 - ETA: >2024-05-25 21:31:09 +2024-05-25 19:42:34 (UTC) - 0:15:58 - train - INFO - step: 000039 - done (%): 13.0 - loss: 2.430 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5534.8 - avg_words_per_second: 1342.8 - ETA: >2024-05-25 21:28:43 +2024-05-25 19:42:40 (UTC) - 0:16:04 - train - INFO - step: 000040 - done (%): 13.3 - loss: 1.571 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.9 - avg_words_per_second: 1368.8 - ETA: >2024-05-25 21:26:24 +2024-05-25 19:42:46 (UTC) - 0:16:10 - train - INFO - step: 000041 - done (%): 13.7 - loss: 1.559 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5531.9 - avg_words_per_second: 1394.4 - ETA: >2024-05-25 21:24:12 +2024-05-25 19:42:51 (UTC) - 0:16:16 - train - INFO - step: 000042 - done (%): 14.0 - loss: 1.158 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5534.1 - avg_words_per_second: 1419.7 - ETA: >2024-05-25 21:22:07 +2024-05-25 19:42:57 (UTC) - 0:16:22 - train - INFO - step: 000043 - done (%): 14.3 - loss: 1.159 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.4 - avg_words_per_second: 1444.7 - ETA: >2024-05-25 21:20:07 +2024-05-25 19:43:03 (UTC) - 0:16:27 - train - INFO - step: 000044 - done (%): 14.7 - loss: 1.947 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5551.0 - avg_words_per_second: 1469.4 - ETA: >2024-05-25 21:18:12 +2024-05-25 19:43:09 (UTC) - 0:16:33 - train - INFO - step: 000045 - done (%): 15.0 - loss: 1.768 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5550.5 - avg_words_per_second: 1493.8 - ETA: >2024-05-25 21:16:23 +2024-05-25 19:43:15 (UTC) - 0:16:39 - train - INFO - step: 000046 - done (%): 15.3 - loss: 1.301 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5544.8 - avg_words_per_second: 1517.9 - ETA: >2024-05-25 21:14:38 +2024-05-25 19:43:21 (UTC) - 0:16:45 - train - INFO - step: 000047 - done (%): 15.7 - loss: 1.633 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5544.2 - avg_words_per_second: 1541.7 - ETA: >2024-05-25 21:12:58 +2024-05-25 19:43:27 (UTC) - 0:16:51 - train - INFO - step: 000048 - done (%): 16.0 - loss: 1.854 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.6 - avg_words_per_second: 1565.3 - ETA: >2024-05-25 21:11:22 +2024-05-25 19:43:33 (UTC) - 0:16:57 - train - INFO - step: 000049 - done (%): 16.3 - loss: 1.856 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5550.7 - avg_words_per_second: 1588.5 - ETA: >2024-05-25 21:09:50 +2024-05-25 19:43:39 (UTC) - 0:17:03 - train - INFO - step: 000050 - done (%): 16.7 - loss: 1.311 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5532.3 - avg_words_per_second: 1611.5 - ETA: >2024-05-25 21:08:22 +2024-05-25 19:43:45 (UTC) - 0:17:09 - train - INFO - step: 000051 - done (%): 17.0 - loss: 2.006 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5551.2 - avg_words_per_second: 1634.3 - ETA: >2024-05-25 21:06:57 +2024-05-25 19:43:51 (UTC) - 0:17:15 - train - INFO - step: 000052 - done (%): 17.3 - loss: 1.685 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5542.7 - avg_words_per_second: 1656.7 - ETA: >2024-05-25 21:05:36 +2024-05-25 19:43:56 (UTC) - 0:17:21 - train - INFO - step: 000053 - done (%): 17.7 - loss: 1.166 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5544.2 - avg_words_per_second: 1678.9 - ETA: >2024-05-25 21:04:17 +2024-05-25 19:44:02 (UTC) - 0:17:27 - train - INFO - step: 000054 - done (%): 18.0 - loss: 2.070 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5522.4 - avg_words_per_second: 1700.8 - ETA: >2024-05-25 21:03:02 +2024-05-25 19:44:08 (UTC) - 0:17:32 - train - INFO - step: 000055 - done (%): 18.3 - loss: 1.363 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5544.3 - avg_words_per_second: 1722.6 - ETA: >2024-05-25 21:01:49 +2024-05-25 19:44:14 (UTC) - 0:17:38 - train - INFO - step: 000056 - done (%): 18.7 - loss: 1.466 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5531.7 - avg_words_per_second: 1744.0 - ETA: >2024-05-25 21:00:39 +2024-05-25 19:44:20 (UTC) - 0:17:44 - train - INFO - step: 000057 - done (%): 19.0 - loss: 1.318 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5545.7 - avg_words_per_second: 1765.2 - ETA: >2024-05-25 20:59:31 +2024-05-25 19:44:26 (UTC) - 0:17:50 - train - INFO - step: 000058 - done (%): 19.3 - loss: 2.132 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5526.4 - avg_words_per_second: 1786.2 - ETA: >2024-05-25 20:58:26 +2024-05-25 19:44:32 (UTC) - 0:17:56 - train - INFO - step: 000059 - done (%): 19.7 - loss: 1.420 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.4 - avg_words_per_second: 1807.0 - ETA: >2024-05-25 20:57:22 +2024-05-25 19:44:38 (UTC) - 0:18:02 - train - INFO - step: 000060 - done (%): 20.0 - loss: 2.135 - lr: 5.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.3 - avg_words_per_second: 1827.5 - ETA: >2024-05-25 20:56:21 +2024-05-25 19:44:44 (UTC) - 0:18:08 - train - INFO - step: 000061 - done (%): 20.3 - loss: 1.724 - lr: 5.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5537.9 - avg_words_per_second: 1847.8 - ETA: >2024-05-25 20:55:22 +2024-05-25 19:44:50 (UTC) - 0:18:14 - train - INFO - step: 000062 - done (%): 20.7 - loss: 1.734 - lr: 5.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5524.4 - avg_words_per_second: 1867.9 - ETA: >2024-05-25 20:54:25 +2024-05-25 19:44:56 (UTC) - 0:18:20 - train - INFO - step: 000063 - done (%): 21.0 - loss: 1.548 - lr: 5.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.9 - avg_words_per_second: 1887.7 - ETA: >2024-05-25 20:53:30 +2024-05-25 19:45:02 (UTC) - 0:18:26 - train - INFO - step: 000064 - done (%): 21.3 - loss: 1.666 - lr: 5.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.2 - avg_words_per_second: 1907.4 - ETA: >2024-05-25 20:52:36 +2024-05-25 19:45:07 (UTC) - 0:18:32 - train - INFO - step: 000065 - done (%): 21.7 - loss: 1.530 - lr: 5.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5551.5 - avg_words_per_second: 1926.9 - ETA: >2024-05-25 20:51:44 +2024-05-25 19:45:13 (UTC) - 0:18:38 - train - INFO - step: 000066 - done (%): 22.0 - loss: 1.554 - lr: 5.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.3 - avg_words_per_second: 1946.1 - ETA: >2024-05-25 20:50:53 +2024-05-25 19:45:19 (UTC) - 0:18:43 - train - INFO - step: 000067 - done (%): 22.3 - loss: 1.927 - lr: 5.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5537.5 - avg_words_per_second: 1965.1 - ETA: >2024-05-25 20:50:04 +2024-05-25 19:45:25 (UTC) - 0:18:49 - train - INFO - step: 000068 - done (%): 22.7 - loss: 2.109 - lr: 5.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.1 - avg_words_per_second: 1984.0 - ETA: >2024-05-25 20:49:17 +2024-05-25 19:45:31 (UTC) - 0:18:55 - train - INFO - step: 000069 - done (%): 23.0 - loss: 1.719 - lr: 5.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.6 - avg_words_per_second: 2002.6 - ETA: >2024-05-25 20:48:31 +2024-05-25 19:45:37 (UTC) - 0:19:01 - train - INFO - step: 000070 - done (%): 23.3 - loss: 1.535 - lr: 5.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5564.0 - avg_words_per_second: 2021.1 - ETA: >2024-05-25 20:47:46 +2024-05-25 19:45:43 (UTC) - 0:19:07 - train - INFO - step: 000071 - done (%): 23.7 - loss: 1.952 - lr: 5.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5560.1 - avg_words_per_second: 2039.4 - ETA: >2024-05-25 20:47:02 +2024-05-25 19:45:49 (UTC) - 0:19:13 - train - INFO - step: 000072 - done (%): 24.0 - loss: 1.430 - lr: 5.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.5 - avg_words_per_second: 2057.5 - ETA: >2024-05-25 20:46:20 +2024-05-25 19:45:55 (UTC) - 0:19:19 - train - INFO - step: 000073 - done (%): 24.3 - loss: 1.582 - lr: 5.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5563.6 - avg_words_per_second: 2075.4 - ETA: >2024-05-25 20:45:39 +2024-05-25 19:46:01 (UTC) - 0:19:25 - train - INFO - step: 000074 - done (%): 24.7 - loss: 1.675 - lr: 5.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5543.5 - avg_words_per_second: 2093.1 - ETA: >2024-05-25 20:44:59 +2024-05-25 19:46:06 (UTC) - 0:19:31 - train - INFO - step: 000075 - done (%): 25.0 - loss: 1.511 - lr: 5.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5561.7 - avg_words_per_second: 2110.6 - ETA: >2024-05-25 20:44:20 +2024-05-25 19:46:12 (UTC) - 0:19:37 - train - INFO - step: 000076 - done (%): 25.3 - loss: 1.515 - lr: 5.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5566.7 - avg_words_per_second: 2128.0 - ETA: >2024-05-25 20:43:42 +2024-05-25 19:46:18 (UTC) - 0:19:42 - train - INFO - step: 000077 - done (%): 25.7 - loss: 1.338 - lr: 5.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.3 - avg_words_per_second: 2145.2 - ETA: >2024-05-25 20:43:05 +2024-05-25 19:46:24 (UTC) - 0:19:48 - train - INFO - step: 000078 - done (%): 26.0 - loss: 1.931 - lr: 5.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.9 - avg_words_per_second: 2162.2 - ETA: >2024-05-25 20:42:28 +2024-05-25 19:46:30 (UTC) - 0:19:54 - train - INFO - step: 000079 - done (%): 26.3 - loss: 1.501 - lr: 5.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.9 - avg_words_per_second: 2179.0 - ETA: >2024-05-25 20:41:53 +2024-05-25 19:46:36 (UTC) - 0:20:00 - train - INFO - step: 000080 - done (%): 26.7 - loss: 1.467 - lr: 5.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5569.1 - avg_words_per_second: 2195.8 - ETA: >2024-05-25 20:41:19 +2024-05-25 19:46:42 (UTC) - 0:20:06 - train - INFO - step: 000081 - done (%): 27.0 - loss: 1.537 - lr: 5.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5566.1 - avg_words_per_second: 2212.3 - ETA: >2024-05-25 20:40:46 +2024-05-25 19:46:48 (UTC) - 0:20:12 - train - INFO - step: 000082 - done (%): 27.3 - loss: 1.464 - lr: 5.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5559.9 - avg_words_per_second: 2228.7 - ETA: >2024-05-25 20:40:13 +2024-05-25 19:46:54 (UTC) - 0:20:18 - train - INFO - step: 000083 - done (%): 27.7 - loss: 1.965 - lr: 5.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5561.5 - avg_words_per_second: 2244.9 - ETA: >2024-05-25 20:39:41 +2024-05-25 19:46:59 (UTC) - 0:20:24 - train - INFO - step: 000084 - done (%): 28.0 - loss: 1.145 - lr: 5.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5567.4 - avg_words_per_second: 2260.9 - ETA: >2024-05-25 20:39:10 +2024-05-25 19:47:05 (UTC) - 0:20:30 - train - INFO - step: 000085 - done (%): 28.3 - loss: 1.267 - lr: 5.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5561.3 - avg_words_per_second: 2276.8 - ETA: >2024-05-25 20:38:40 +2024-05-25 19:47:11 (UTC) - 0:20:35 - train - INFO - step: 000086 - done (%): 28.7 - loss: 1.425 - lr: 5.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5565.1 - avg_words_per_second: 2292.6 - ETA: >2024-05-25 20:38:10 +2024-05-25 19:47:17 (UTC) - 0:20:41 - train - INFO - step: 000087 - done (%): 29.0 - loss: 1.809 - lr: 5.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5570.9 - avg_words_per_second: 2308.2 - ETA: >2024-05-25 20:37:41 +2024-05-25 19:47:23 (UTC) - 0:20:47 - train - INFO - step: 000088 - done (%): 29.3 - loss: 1.969 - lr: 5.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5567.1 - avg_words_per_second: 2323.6 - ETA: >2024-05-25 20:37:13 +2024-05-25 19:47:29 (UTC) - 0:20:53 - train - INFO - step: 000089 - done (%): 29.7 - loss: 1.746 - lr: 5.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5560.6 - avg_words_per_second: 2338.9 - ETA: >2024-05-25 20:36:45 +2024-05-25 19:47:35 (UTC) - 0:20:59 - train - INFO - step: 000090 - done (%): 30.0 - loss: 1.215 - lr: 5.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.2 - avg_words_per_second: 2354.1 - ETA: >2024-05-25 20:36:18 +2024-05-25 19:47:41 (UTC) - 0:21:05 - train - INFO - step: 000091 - done (%): 30.3 - loss: 1.321 - lr: 5.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5569.9 - avg_words_per_second: 2369.1 - ETA: >2024-05-25 20:35:51 +2024-05-25 19:47:47 (UTC) - 0:21:11 - train - INFO - step: 000092 - done (%): 30.7 - loss: 1.345 - lr: 5.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5536.2 - avg_words_per_second: 2383.9 - ETA: >2024-05-25 20:35:26 +2024-05-25 19:47:53 (UTC) - 0:21:17 - train - INFO - step: 000093 - done (%): 31.0 - loss: 1.334 - lr: 5.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5565.3 - avg_words_per_second: 2398.7 - ETA: >2024-05-25 20:35:00 +2024-05-25 19:47:58 (UTC) - 0:21:23 - train - INFO - step: 000094 - done (%): 31.3 - loss: 1.270 - lr: 4.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5550.7 - avg_words_per_second: 2413.2 - ETA: >2024-05-25 20:34:36 +2024-05-25 19:48:04 (UTC) - 0:21:29 - train - INFO - step: 000095 - done (%): 31.7 - loss: 1.343 - lr: 4.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5560.9 - avg_words_per_second: 2427.7 - ETA: >2024-05-25 20:34:11 +2024-05-25 19:48:10 (UTC) - 0:21:34 - train - INFO - step: 000096 - done (%): 32.0 - loss: 1.927 - lr: 4.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5557.8 - avg_words_per_second: 2442.0 - ETA: >2024-05-25 20:33:48 +2024-05-25 19:48:16 (UTC) - 0:21:40 - train - INFO - step: 000097 - done (%): 32.3 - loss: 1.121 - lr: 4.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5568.1 - avg_words_per_second: 2456.3 - ETA: >2024-05-25 20:33:24 +2024-05-25 19:48:22 (UTC) - 0:21:46 - train - INFO - step: 000098 - done (%): 32.7 - loss: 1.686 - lr: 4.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5561.8 - avg_words_per_second: 2470.3 - ETA: >2024-05-25 20:33:01 +2024-05-25 19:48:28 (UTC) - 0:21:52 - train - INFO - step: 000099 - done (%): 33.0 - loss: 1.768 - lr: 4.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5563.3 - avg_words_per_second: 2484.3 - ETA: >2024-05-25 20:32:39 +2024-05-25 19:48:34 (UTC) - 0:21:58 - train - INFO - step: 000100 - done (%): 33.3 - loss: 1.165 - lr: 4.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5577.6 - avg_words_per_second: 2498.1 - ETA: >2024-05-25 20:32:17 +2024-05-25 19:48:34 (UTC) - 0:21:58 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runs/checkpoints/checkpoint_000100/consolidated using tmp name: tmp.consolidated +2024-05-25 19:48:34 (UTC) - 0:21:58 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runs/checkpoints/checkpoint_000100/consolidated for step: 100 +2024-05-25 19:48:34 (UTC) - 0:21:58 - checkpointing - INFO - Done deleting checkpoints +2024-05-25 19:48:34 (UTC) - 0:21:58 - checkpointing - INFO - Done! +2024-05-25 19:48:40 (UTC) - 0:22:04 - train - INFO - step: 000101 - done (%): 33.7 - loss: 1.225 - lr: 4.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5589.2 - avg_words_per_second: 2511.9 - ETA: >2024-05-25 20:31:56 +2024-05-25 19:48:46 (UTC) - 0:22:10 - train - INFO - step: 000102 - done (%): 34.0 - loss: 1.568 - lr: 4.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5550.5 - avg_words_per_second: 2525.4 - ETA: >2024-05-25 20:31:35 +2024-05-25 19:48:52 (UTC) - 0:22:16 - train - INFO - step: 000103 - done (%): 34.3 - loss: 1.692 - lr: 4.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5578.6 - avg_words_per_second: 2538.9 - ETA: >2024-05-25 20:31:14 +2024-05-25 19:48:58 (UTC) - 0:22:22 - train - INFO - step: 000104 - done (%): 34.7 - loss: 1.895 - lr: 4.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5571.7 - avg_words_per_second: 2552.3 - ETA: >2024-05-25 20:30:54 +2024-05-25 19:49:04 (UTC) - 0:22:28 - train - INFO - step: 000105 - done (%): 35.0 - loss: 1.636 - lr: 4.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5574.5 - avg_words_per_second: 2565.5 - ETA: >2024-05-25 20:30:34 +2024-05-25 19:49:09 (UTC) - 0:22:34 - train - INFO - step: 000106 - done (%): 35.3 - loss: 1.224 - lr: 4.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5571.8 - avg_words_per_second: 2578.7 - ETA: >2024-05-25 20:30:15 +2024-05-25 19:49:15 (UTC) - 0:22:40 - train - INFO - step: 000107 - done (%): 35.7 - loss: 1.875 - lr: 4.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5564.6 - avg_words_per_second: 2591.7 - ETA: >2024-05-25 20:29:56 +2024-05-25 19:49:21 (UTC) - 0:22:45 - train - INFO - step: 000108 - done (%): 36.0 - loss: 2.010 - lr: 4.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5558.9 - avg_words_per_second: 2604.5 - ETA: >2024-05-25 20:29:37 +2024-05-25 19:49:37 (UTC) - 0:23:01 - train - INFO - step: 000109 - done (%): 36.3 - loss: 1.450 - lr: 4.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 2062.2 - avg_words_per_second: 2598.3 - ETA: >2024-05-25 20:29:46 +2024-05-25 19:49:43 (UTC) - 0:23:07 - train - INFO - step: 000110 - done (%): 36.7 - loss: 1.785 - lr: 4.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5594.7 - avg_words_per_second: 2611.0 - ETA: >2024-05-25 20:29:28 +2024-05-25 19:49:49 (UTC) - 0:23:13 - train - INFO - step: 000111 - done (%): 37.0 - loss: 1.580 - lr: 4.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5588.7 - avg_words_per_second: 2623.6 - ETA: >2024-05-25 20:29:09 +2024-05-25 19:49:55 (UTC) - 0:23:19 - train - INFO - step: 000112 - done (%): 37.3 - loss: 1.452 - lr: 4.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5578.7 - avg_words_per_second: 2636.0 - ETA: >2024-05-25 20:28:52 +2024-05-25 19:50:01 (UTC) - 0:23:25 - train - INFO - step: 000113 - done (%): 37.7 - loss: 1.927 - lr: 4.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5558.7 - avg_words_per_second: 2648.4 - ETA: >2024-05-25 20:28:34 +2024-05-25 19:50:07 (UTC) - 0:23:31 - train - INFO - step: 000114 - done (%): 38.0 - loss: 1.293 - lr: 4.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5568.6 - avg_words_per_second: 2660.6 - ETA: >2024-05-25 20:28:17 +2024-05-25 19:50:12 (UTC) - 0:23:37 - train - INFO - step: 000115 - done (%): 38.3 - loss: 1.955 - lr: 4.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5566.1 - avg_words_per_second: 2672.7 - ETA: >2024-05-25 20:28:01 +2024-05-25 19:50:18 (UTC) - 0:23:43 - train - INFO - step: 000116 - done (%): 38.7 - loss: 1.356 - lr: 4.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.2 - avg_words_per_second: 2684.7 - ETA: >2024-05-25 20:27:44 +2024-05-25 19:50:24 (UTC) - 0:23:48 - train - INFO - step: 000117 - done (%): 39.0 - loss: 1.443 - lr: 4.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5524.7 - avg_words_per_second: 2696.6 - ETA: >2024-05-25 20:27:28 +2024-05-25 19:50:30 (UTC) - 0:23:54 - train - INFO - step: 000118 - done (%): 39.3 - loss: 2.062 - lr: 4.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.1 - avg_words_per_second: 2708.4 - ETA: >2024-05-25 20:27:12 +2024-05-25 19:50:36 (UTC) - 0:24:00 - train - INFO - step: 000119 - done (%): 39.7 - loss: 1.449 - lr: 4.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.1 - avg_words_per_second: 2720.1 - ETA: >2024-05-25 20:26:57 +2024-05-25 19:50:42 (UTC) - 0:24:06 - train - INFO - step: 000120 - done (%): 40.0 - loss: 1.723 - lr: 4.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.9 - avg_words_per_second: 2731.7 - ETA: >2024-05-25 20:26:41 +2024-05-25 19:50:48 (UTC) - 0:24:12 - train - INFO - step: 000121 - done (%): 40.3 - loss: 1.361 - lr: 4.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.0 - avg_words_per_second: 2743.2 - ETA: >2024-05-25 20:26:26 +2024-05-25 19:50:54 (UTC) - 0:24:18 - train - INFO - step: 000122 - done (%): 40.7 - loss: 1.392 - lr: 4.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.3 - avg_words_per_second: 2754.7 - ETA: >2024-05-25 20:26:11 +2024-05-25 19:51:00 (UTC) - 0:24:24 - train - INFO - step: 000123 - done (%): 41.0 - loss: 1.623 - lr: 4.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5529.5 - avg_words_per_second: 2765.9 - ETA: >2024-05-25 20:25:57 +2024-05-25 19:51:06 (UTC) - 0:24:30 - train - INFO - step: 000124 - done (%): 41.3 - loss: 2.118 - lr: 4.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.1 - avg_words_per_second: 2777.2 - ETA: >2024-05-25 20:25:42 +2024-05-25 19:51:11 (UTC) - 0:24:36 - train - INFO - step: 000125 - done (%): 41.7 - loss: 1.705 - lr: 4.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5563.5 - avg_words_per_second: 2788.4 - ETA: >2024-05-25 20:25:28 +2024-05-25 19:51:17 (UTC) - 0:24:42 - train - INFO - step: 000126 - done (%): 42.0 - loss: 1.196 - lr: 4.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.7 - avg_words_per_second: 2799.4 - ETA: >2024-05-25 20:25:14 +2024-05-25 19:51:23 (UTC) - 0:24:48 - train - INFO - step: 000127 - done (%): 42.3 - loss: 1.647 - lr: 4.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5537.3 - avg_words_per_second: 2810.4 - ETA: >2024-05-25 20:25:00 +2024-05-25 19:51:29 (UTC) - 0:24:53 - train - INFO - step: 000128 - done (%): 42.7 - loss: 1.432 - lr: 4.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.4 - avg_words_per_second: 2821.2 - ETA: >2024-05-25 20:24:47 +2024-05-25 19:51:35 (UTC) - 0:24:59 - train - INFO - step: 000129 - done (%): 43.0 - loss: 0.965 - lr: 3.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5540.2 - avg_words_per_second: 2832.0 - ETA: >2024-05-25 20:24:34 +2024-05-25 19:51:41 (UTC) - 0:25:05 - train - INFO - step: 000130 - done (%): 43.3 - loss: 1.659 - lr: 3.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5542.8 - avg_words_per_second: 2842.7 - ETA: >2024-05-25 20:24:21 +2024-05-25 19:51:47 (UTC) - 0:25:11 - train - INFO - step: 000131 - done (%): 43.7 - loss: 1.339 - lr: 3.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5562.3 - avg_words_per_second: 2853.4 - ETA: >2024-05-25 20:24:08 +2024-05-25 19:51:53 (UTC) - 0:25:17 - train - INFO - step: 000132 - done (%): 44.0 - loss: 1.543 - lr: 3.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5539.2 - avg_words_per_second: 2863.9 - ETA: >2024-05-25 20:23:55 +2024-05-25 19:51:59 (UTC) - 0:25:23 - train - INFO - step: 000133 - done (%): 44.3 - loss: 1.560 - lr: 3.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5550.3 - avg_words_per_second: 2874.3 - ETA: >2024-05-25 20:23:43 +2024-05-25 19:52:05 (UTC) - 0:25:29 - train - INFO - step: 000134 - done (%): 44.7 - loss: 1.300 - lr: 3.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5550.5 - avg_words_per_second: 2884.7 - ETA: >2024-05-25 20:23:30 +2024-05-25 19:52:11 (UTC) - 0:25:35 - train - INFO - step: 000135 - done (%): 45.0 - loss: 1.651 - lr: 3.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.0 - avg_words_per_second: 2895.0 - ETA: >2024-05-25 20:23:18 +2024-05-25 19:52:16 (UTC) - 0:25:41 - train - INFO - step: 000136 - done (%): 45.3 - loss: 1.487 - lr: 3.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5551.4 - avg_words_per_second: 2905.2 - ETA: >2024-05-25 20:23:06 +2024-05-25 19:52:22 (UTC) - 0:25:47 - train - INFO - step: 000137 - done (%): 45.7 - loss: 1.417 - lr: 3.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.8 - avg_words_per_second: 2915.4 - ETA: >2024-05-25 20:22:54 +2024-05-25 19:52:28 (UTC) - 0:25:53 - train - INFO - step: 000138 - done (%): 46.0 - loss: 1.342 - lr: 3.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5529.0 - avg_words_per_second: 2925.4 - ETA: >2024-05-25 20:22:43 +2024-05-25 19:52:34 (UTC) - 0:25:58 - train - INFO - step: 000139 - done (%): 46.3 - loss: 1.417 - lr: 3.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5550.6 - avg_words_per_second: 2935.4 - ETA: >2024-05-25 20:22:31 +2024-05-25 19:52:40 (UTC) - 0:26:04 - train - INFO - step: 000140 - done (%): 46.7 - loss: 1.413 - lr: 3.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.0 - avg_words_per_second: 2945.3 - ETA: >2024-05-25 20:22:20 +2024-05-25 19:52:46 (UTC) - 0:26:10 - train - INFO - step: 000141 - done (%): 47.0 - loss: 1.222 - lr: 3.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.1 - avg_words_per_second: 2955.1 - ETA: >2024-05-25 20:22:09 +2024-05-25 19:52:52 (UTC) - 0:26:16 - train - INFO - step: 000142 - done (%): 47.3 - loss: 2.071 - lr: 3.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5543.9 - avg_words_per_second: 2964.9 - ETA: >2024-05-25 20:21:58 +2024-05-25 19:52:58 (UTC) - 0:26:22 - train - INFO - step: 000143 - done (%): 47.7 - loss: 1.308 - lr: 3.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5559.2 - avg_words_per_second: 2974.6 - ETA: >2024-05-25 20:21:47 +2024-05-25 19:53:04 (UTC) - 0:26:28 - train - INFO - step: 000144 - done (%): 48.0 - loss: 1.589 - lr: 3.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5543.1 - avg_words_per_second: 2984.2 - ETA: >2024-05-25 20:21:37 +2024-05-25 19:53:10 (UTC) - 0:26:34 - train - INFO - step: 000145 - done (%): 48.3 - loss: 1.951 - lr: 3.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5542.6 - avg_words_per_second: 2993.7 - ETA: >2024-05-25 20:21:26 +2024-05-25 19:53:16 (UTC) - 0:26:40 - train - INFO - step: 000146 - done (%): 48.7 - loss: 1.525 - lr: 3.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5561.8 - avg_words_per_second: 3003.2 - ETA: >2024-05-25 20:21:16 +2024-05-25 19:53:21 (UTC) - 0:26:46 - train - INFO - step: 000147 - done (%): 49.0 - loss: 1.357 - lr: 3.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.1 - avg_words_per_second: 3012.6 - ETA: >2024-05-25 20:21:06 +2024-05-25 19:53:27 (UTC) - 0:26:52 - train - INFO - step: 000148 - done (%): 49.3 - loss: 1.433 - lr: 3.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5541.9 - avg_words_per_second: 3022.0 - ETA: >2024-05-25 20:20:56 +2024-05-25 19:53:33 (UTC) - 0:26:57 - train - INFO - step: 000149 - done (%): 49.7 - loss: 1.440 - lr: 3.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.1 - avg_words_per_second: 3031.2 - ETA: >2024-05-25 20:20:46 +2024-05-25 19:53:39 (UTC) - 0:27:03 - train - INFO - step: 000150 - done (%): 50.0 - loss: 1.677 - lr: 3.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.7 - avg_words_per_second: 3040.4 - ETA: >2024-05-25 20:20:36 +2024-05-25 19:53:45 (UTC) - 0:27:09 - train - INFO - step: 000151 - done (%): 50.3 - loss: 1.960 - lr: 3.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5547.6 - avg_words_per_second: 3049.6 - ETA: >2024-05-25 20:20:26 +2024-05-25 19:53:51 (UTC) - 0:27:15 - train - INFO - step: 000152 - done (%): 50.7 - loss: 0.654 - lr: 3.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5547.2 - avg_words_per_second: 3058.6 - ETA: >2024-05-25 20:20:17 +2024-05-25 19:53:57 (UTC) - 0:27:21 - train - INFO - step: 000153 - done (%): 51.0 - loss: 1.543 - lr: 3.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.0 - avg_words_per_second: 3067.6 - ETA: >2024-05-25 20:20:07 +2024-05-25 19:54:03 (UTC) - 0:27:27 - train - INFO - step: 000154 - done (%): 51.3 - loss: 2.112 - lr: 3.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5535.0 - avg_words_per_second: 3076.5 - ETA: >2024-05-25 20:19:58 +2024-05-25 19:54:09 (UTC) - 0:27:33 - train - INFO - step: 000155 - done (%): 51.7 - loss: 1.610 - lr: 3.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.4 - avg_words_per_second: 3085.4 - ETA: >2024-05-25 20:19:49 +2024-05-25 19:54:15 (UTC) - 0:27:39 - train - INFO - step: 000156 - done (%): 52.0 - loss: 1.624 - lr: 3.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5561.5 - avg_words_per_second: 3094.2 - ETA: >2024-05-25 20:19:40 +2024-05-25 19:54:21 (UTC) - 0:27:45 - train - INFO - step: 000157 - done (%): 52.3 - loss: 1.757 - lr: 3.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.2 - avg_words_per_second: 3103.0 - ETA: >2024-05-25 20:19:31 +2024-05-25 19:54:26 (UTC) - 0:27:51 - train - INFO - step: 000158 - done (%): 52.7 - loss: 1.549 - lr: 3.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5547.8 - avg_words_per_second: 3111.7 - ETA: >2024-05-25 20:19:22 +2024-05-25 19:54:32 (UTC) - 0:27:57 - train - INFO - step: 000159 - done (%): 53.0 - loss: 1.454 - lr: 3.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5551.7 - avg_words_per_second: 3120.3 - ETA: >2024-05-25 20:19:13 +2024-05-25 19:54:38 (UTC) - 0:28:02 - train - INFO - step: 000160 - done (%): 53.3 - loss: 1.501 - lr: 2.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.4 - avg_words_per_second: 3128.9 - ETA: >2024-05-25 20:19:04 +2024-05-25 19:54:44 (UTC) - 0:28:08 - train - INFO - step: 000161 - done (%): 53.7 - loss: 1.490 - lr: 2.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.2 - avg_words_per_second: 3137.4 - ETA: >2024-05-25 20:18:56 +2024-05-25 19:54:50 (UTC) - 0:28:14 - train - INFO - step: 000162 - done (%): 54.0 - loss: 1.959 - lr: 2.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.3 - avg_words_per_second: 3145.8 - ETA: >2024-05-25 20:18:47 +2024-05-25 19:54:56 (UTC) - 0:28:20 - train - INFO - step: 000163 - done (%): 54.3 - loss: 1.457 - lr: 2.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.4 - avg_words_per_second: 3154.2 - ETA: >2024-05-25 20:18:39 +2024-05-25 19:55:02 (UTC) - 0:28:26 - train - INFO - step: 000164 - done (%): 54.7 - loss: 1.364 - lr: 2.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5542.9 - avg_words_per_second: 3162.5 - ETA: >2024-05-25 20:18:31 +2024-05-25 19:55:08 (UTC) - 0:28:32 - train - INFO - step: 000165 - done (%): 55.0 - loss: 1.366 - lr: 2.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.3 - avg_words_per_second: 3170.8 - ETA: >2024-05-25 20:18:23 +2024-05-25 19:55:14 (UTC) - 0:28:38 - train - INFO - step: 000166 - done (%): 55.3 - loss: 1.227 - lr: 2.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.3 - avg_words_per_second: 3179.0 - ETA: >2024-05-25 20:18:15 +2024-05-25 19:55:20 (UTC) - 0:28:44 - train - INFO - step: 000167 - done (%): 55.7 - loss: 1.454 - lr: 2.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5561.7 - avg_words_per_second: 3187.2 - ETA: >2024-05-25 20:18:07 +2024-05-25 19:55:25 (UTC) - 0:28:50 - train - INFO - step: 000168 - done (%): 56.0 - loss: 1.402 - lr: 2.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.6 - avg_words_per_second: 3195.3 - ETA: >2024-05-25 20:17:59 +2024-05-25 19:55:31 (UTC) - 0:28:56 - train - INFO - step: 000169 - done (%): 56.3 - loss: 1.240 - lr: 2.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5550.7 - avg_words_per_second: 3203.3 - ETA: >2024-05-25 20:17:51 +2024-05-25 19:55:37 (UTC) - 0:29:01 - train - INFO - step: 000170 - done (%): 56.7 - loss: 1.377 - lr: 2.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.7 - avg_words_per_second: 3211.3 - ETA: >2024-05-25 20:17:44 +2024-05-25 19:55:43 (UTC) - 0:29:07 - train - INFO - step: 000171 - done (%): 57.0 - loss: 1.627 - lr: 2.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5537.6 - avg_words_per_second: 3219.2 - ETA: >2024-05-25 20:17:36 +2024-05-25 19:55:49 (UTC) - 0:29:13 - train - INFO - step: 000172 - done (%): 57.3 - loss: 1.368 - lr: 2.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.7 - avg_words_per_second: 3227.1 - ETA: >2024-05-25 20:17:29 +2024-05-25 19:55:55 (UTC) - 0:29:19 - train - INFO - step: 000173 - done (%): 57.7 - loss: 1.635 - lr: 2.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.8 - avg_words_per_second: 3234.9 - ETA: >2024-05-25 20:17:21 +2024-05-25 19:56:01 (UTC) - 0:29:25 - train - INFO - step: 000174 - done (%): 58.0 - loss: 1.210 - lr: 2.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.2 - avg_words_per_second: 3242.7 - ETA: >2024-05-25 20:17:14 +2024-05-25 19:56:07 (UTC) - 0:29:31 - train - INFO - step: 000175 - done (%): 58.3 - loss: 1.538 - lr: 2.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5543.7 - avg_words_per_second: 3250.4 - ETA: >2024-05-25 20:17:07 +2024-05-25 19:56:13 (UTC) - 0:29:37 - train - INFO - step: 000176 - done (%): 58.7 - loss: 1.250 - lr: 2.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.3 - avg_words_per_second: 3258.1 - ETA: >2024-05-25 20:17:00 +2024-05-25 19:56:19 (UTC) - 0:29:43 - train - INFO - step: 000177 - done (%): 59.0 - loss: 1.512 - lr: 2.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5529.1 - avg_words_per_second: 3265.7 - ETA: >2024-05-25 20:16:53 +2024-05-25 19:56:25 (UTC) - 0:29:49 - train - INFO - step: 000178 - done (%): 59.3 - loss: 1.585 - lr: 2.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5550.4 - avg_words_per_second: 3273.2 - ETA: >2024-05-25 20:16:46 +2024-05-25 19:56:30 (UTC) - 0:29:55 - train - INFO - step: 000179 - done (%): 59.7 - loss: 1.637 - lr: 2.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5541.8 - avg_words_per_second: 3280.7 - ETA: >2024-05-25 20:16:39 +2024-05-25 19:56:36 (UTC) - 0:30:01 - train - INFO - step: 000180 - done (%): 60.0 - loss: 1.178 - lr: 2.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.5 - avg_words_per_second: 3288.2 - ETA: >2024-05-25 20:16:32 +2024-05-25 19:56:42 (UTC) - 0:30:06 - train - INFO - step: 000181 - done (%): 60.3 - loss: 1.533 - lr: 2.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5557.2 - avg_words_per_second: 3295.6 - ETA: >2024-05-25 20:16:25 +2024-05-25 19:56:48 (UTC) - 0:30:12 - train - INFO - step: 000182 - done (%): 60.7 - loss: 1.068 - lr: 2.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.7 - avg_words_per_second: 3303.0 - ETA: >2024-05-25 20:16:19 +2024-05-25 19:56:54 (UTC) - 0:30:18 - train - INFO - step: 000183 - done (%): 61.0 - loss: 1.293 - lr: 2.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.0 - avg_words_per_second: 3310.3 - ETA: >2024-05-25 20:16:12 +2024-05-25 19:57:00 (UTC) - 0:30:24 - train - INFO - step: 000184 - done (%): 61.3 - loss: 1.863 - lr: 2.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.7 - avg_words_per_second: 3317.6 - ETA: >2024-05-25 20:16:06 +2024-05-25 19:57:06 (UTC) - 0:30:30 - train - INFO - step: 000185 - done (%): 61.7 - loss: 1.443 - lr: 2.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5540.8 - avg_words_per_second: 3324.8 - ETA: >2024-05-25 20:15:59 +2024-05-25 19:57:12 (UTC) - 0:30:36 - train - INFO - step: 000186 - done (%): 62.0 - loss: 1.048 - lr: 2.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.3 - avg_words_per_second: 3332.0 - ETA: >2024-05-25 20:15:53 +2024-05-25 19:57:18 (UTC) - 0:30:42 - train - INFO - step: 000187 - done (%): 62.3 - loss: 1.716 - lr: 2.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5543.5 - avg_words_per_second: 3339.1 - ETA: >2024-05-25 20:15:47 +2024-05-25 19:57:24 (UTC) - 0:30:48 - train - INFO - step: 000188 - done (%): 62.7 - loss: 1.866 - lr: 2.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5550.5 - avg_words_per_second: 3346.2 - ETA: >2024-05-25 20:15:40 +2024-05-25 19:57:29 (UTC) - 0:30:54 - train - INFO - step: 000189 - done (%): 63.0 - loss: 1.539 - lr: 2.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.4 - avg_words_per_second: 3353.3 - ETA: >2024-05-25 20:15:34 +2024-05-25 19:57:35 (UTC) - 0:31:00 - train - INFO - step: 000190 - done (%): 63.3 - loss: 1.399 - lr: 1.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.8 - avg_words_per_second: 3360.3 - ETA: >2024-05-25 20:15:28 +2024-05-25 19:57:41 (UTC) - 0:31:06 - train - INFO - step: 000191 - done (%): 63.7 - loss: 1.586 - lr: 1.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5544.3 - avg_words_per_second: 3367.2 - ETA: >2024-05-25 20:15:22 +2024-05-25 19:57:47 (UTC) - 0:31:11 - train - INFO - step: 000192 - done (%): 64.0 - loss: 1.782 - lr: 1.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5547.3 - avg_words_per_second: 3374.1 - ETA: >2024-05-25 20:15:16 +2024-05-25 19:57:53 (UTC) - 0:31:17 - train - INFO - step: 000193 - done (%): 64.3 - loss: 1.073 - lr: 1.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5539.6 - avg_words_per_second: 3381.0 - ETA: >2024-05-25 20:15:10 +2024-05-25 19:57:59 (UTC) - 0:31:23 - train - INFO - step: 000194 - done (%): 64.7 - loss: 1.836 - lr: 1.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5483.4 - avg_words_per_second: 3387.7 - ETA: >2024-05-25 20:15:04 +2024-05-25 19:58:05 (UTC) - 0:31:29 - train - INFO - step: 000195 - done (%): 65.0 - loss: 1.668 - lr: 1.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5544.1 - avg_words_per_second: 3394.5 - ETA: >2024-05-25 20:14:59 +2024-05-25 19:58:11 (UTC) - 0:31:35 - train - INFO - step: 000196 - done (%): 65.3 - loss: 1.350 - lr: 1.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5558.4 - avg_words_per_second: 3401.2 - ETA: >2024-05-25 20:14:53 +2024-05-25 19:58:17 (UTC) - 0:31:41 - train - INFO - step: 000197 - done (%): 65.7 - loss: 1.475 - lr: 1.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5541.3 - avg_words_per_second: 3407.9 - ETA: >2024-05-25 20:14:47 +2024-05-25 19:58:23 (UTC) - 0:31:47 - train - INFO - step: 000198 - done (%): 66.0 - loss: 1.627 - lr: 1.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.9 - avg_words_per_second: 3414.6 - ETA: >2024-05-25 20:14:42 +2024-05-25 19:58:29 (UTC) - 0:31:53 - train - INFO - step: 000199 - done (%): 66.3 - loss: 1.643 - lr: 1.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5559.9 - avg_words_per_second: 3421.2 - ETA: >2024-05-25 20:14:36 +2024-05-25 19:58:35 (UTC) - 0:31:59 - train - INFO - step: 000200 - done (%): 66.7 - loss: 1.128 - lr: 1.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5539.8 - avg_words_per_second: 3427.7 - ETA: >2024-05-25 20:14:31 +2024-05-25 19:58:35 (UTC) - 0:31:59 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runs/checkpoints/checkpoint_000200/consolidated using tmp name: tmp.consolidated +2024-05-25 19:58:35 (UTC) - 0:31:59 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runs/checkpoints/checkpoint_000200/consolidated for step: 200 +2024-05-25 19:58:35 (UTC) - 0:31:59 - checkpointing - INFO - Done deleting checkpoints +2024-05-25 19:58:35 (UTC) - 0:31:59 - checkpointing - INFO - Done! +2024-05-25 19:58:41 (UTC) - 0:32:05 - train - INFO - step: 000201 - done (%): 67.0 - loss: 1.734 - lr: 1.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5560.7 - avg_words_per_second: 3434.3 - ETA: >2024-05-25 20:14:25 +2024-05-25 19:58:47 (UTC) - 0:32:11 - train - INFO - step: 000202 - done (%): 67.3 - loss: 1.386 - lr: 1.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5560.2 - avg_words_per_second: 3440.8 - ETA: >2024-05-25 20:14:20 +2024-05-25 19:58:53 (UTC) - 0:32:17 - train - INFO - step: 000203 - done (%): 67.7 - loss: 1.275 - lr: 1.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.6 - avg_words_per_second: 3447.3 - ETA: >2024-05-25 20:14:15 +2024-05-25 19:58:58 (UTC) - 0:32:23 - train - INFO - step: 000204 - done (%): 68.0 - loss: 1.541 - lr: 1.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5558.7 - avg_words_per_second: 3453.7 - ETA: >2024-05-25 20:14:09 +2024-05-25 19:59:04 (UTC) - 0:32:29 - train - INFO - step: 000205 - done (%): 68.3 - loss: 1.884 - lr: 1.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5540.3 - avg_words_per_second: 3460.1 - ETA: >2024-05-25 20:14:04 +2024-05-25 19:59:10 (UTC) - 0:32:34 - train - INFO - step: 000206 - done (%): 68.7 - loss: 1.848 - lr: 1.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.7 - avg_words_per_second: 3466.4 - ETA: >2024-05-25 20:13:59 +2024-05-25 19:59:16 (UTC) - 0:32:40 - train - INFO - step: 000207 - done (%): 69.0 - loss: 1.060 - lr: 1.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.5 - avg_words_per_second: 3472.7 - ETA: >2024-05-25 20:13:54 +2024-05-25 19:59:22 (UTC) - 0:32:46 - train - INFO - step: 000208 - done (%): 69.3 - loss: 1.712 - lr: 1.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5559.6 - avg_words_per_second: 3479.0 - ETA: >2024-05-25 20:13:49 +2024-05-25 19:59:28 (UTC) - 0:32:52 - train - INFO - step: 000209 - done (%): 69.7 - loss: 1.364 - lr: 1.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.9 - avg_words_per_second: 3485.2 - ETA: >2024-05-25 20:13:44 +2024-05-25 19:59:34 (UTC) - 0:32:58 - train - INFO - step: 000210 - done (%): 70.0 - loss: 1.145 - lr: 1.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5536.6 - avg_words_per_second: 3491.4 - ETA: >2024-05-25 20:13:39 +2024-05-25 19:59:40 (UTC) - 0:33:04 - train - INFO - step: 000211 - done (%): 70.3 - loss: 1.690 - lr: 1.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.7 - avg_words_per_second: 3497.5 - ETA: >2024-05-25 20:13:34 +2024-05-25 19:59:46 (UTC) - 0:33:10 - train - INFO - step: 000212 - done (%): 70.7 - loss: 1.531 - lr: 1.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5558.5 - avg_words_per_second: 3503.6 - ETA: >2024-05-25 20:13:29 +2024-05-25 19:59:52 (UTC) - 0:33:16 - train - INFO - step: 000213 - done (%): 71.0 - loss: 1.718 - lr: 1.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5557.9 - avg_words_per_second: 3509.7 - ETA: >2024-05-25 20:13:24 +2024-05-25 19:59:57 (UTC) - 0:33:22 - train - INFO - step: 000214 - done (%): 71.3 - loss: 1.125 - lr: 1.3e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5558.5 - avg_words_per_second: 3515.8 - ETA: >2024-05-25 20:13:19 +2024-05-25 20:00:03 (UTC) - 0:33:28 - train - INFO - step: 000215 - done (%): 71.7 - loss: 1.082 - lr: 1.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.9 - avg_words_per_second: 3521.8 - ETA: >2024-05-25 20:13:14 +2024-05-25 20:00:09 (UTC) - 0:33:34 - train - INFO - step: 000216 - done (%): 72.0 - loss: 1.169 - lr: 1.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.4 - avg_words_per_second: 3527.7 - ETA: >2024-05-25 20:13:10 +2024-05-25 20:00:15 (UTC) - 0:33:39 - train - INFO - step: 000217 - done (%): 72.3 - loss: 1.326 - lr: 1.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5559.3 - avg_words_per_second: 3533.7 - ETA: >2024-05-25 20:13:05 +2024-05-25 20:00:21 (UTC) - 0:33:45 - train - INFO - step: 000218 - done (%): 72.7 - loss: 1.804 - lr: 1.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5545.6 - avg_words_per_second: 3539.6 - ETA: >2024-05-25 20:13:00 +2024-05-25 20:00:27 (UTC) - 0:33:51 - train - INFO - step: 000219 - done (%): 73.0 - loss: 1.222 - lr: 1.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5547.8 - avg_words_per_second: 3545.4 - ETA: >2024-05-25 20:12:56 +2024-05-25 20:00:33 (UTC) - 0:33:57 - train - INFO - step: 000220 - done (%): 73.3 - loss: 1.779 - lr: 1.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.5 - avg_words_per_second: 3551.3 - ETA: >2024-05-25 20:12:51 +2024-05-25 20:00:39 (UTC) - 0:34:03 - train - INFO - step: 000221 - done (%): 73.7 - loss: 1.709 - lr: 1.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5551.7 - avg_words_per_second: 3557.1 - ETA: >2024-05-25 20:12:47 +2024-05-25 20:00:45 (UTC) - 0:34:09 - train - INFO - step: 000222 - done (%): 74.0 - loss: 1.479 - lr: 1.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.2 - avg_words_per_second: 3562.8 - ETA: >2024-05-25 20:12:42 +2024-05-25 20:00:51 (UTC) - 0:34:15 - train - INFO - step: 000223 - done (%): 74.3 - loss: 1.027 - lr: 1.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5547.0 - avg_words_per_second: 3568.6 - ETA: >2024-05-25 20:12:38 +2024-05-25 20:00:57 (UTC) - 0:34:21 - train - INFO - step: 000224 - done (%): 74.7 - loss: 1.587 - lr: 9.9e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.0 - avg_words_per_second: 3574.3 - ETA: >2024-05-25 20:12:33 +2024-05-25 20:01:02 (UTC) - 0:34:27 - train - INFO - step: 000225 - done (%): 75.0 - loss: 1.393 - lr: 9.7e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.7 - avg_words_per_second: 3579.9 - ETA: >2024-05-25 20:12:29 +2024-05-25 20:01:08 (UTC) - 0:34:33 - train - INFO - step: 000226 - done (%): 75.3 - loss: 1.493 - lr: 9.4e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5544.1 - avg_words_per_second: 3585.5 - ETA: >2024-05-25 20:12:25 +2024-05-25 20:01:14 (UTC) - 0:34:38 - train - INFO - step: 000227 - done (%): 75.7 - loss: 1.420 - lr: 9.2e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.7 - avg_words_per_second: 3591.1 - ETA: >2024-05-25 20:12:20 +2024-05-25 20:01:20 (UTC) - 0:34:44 - train - INFO - step: 000228 - done (%): 76.0 - loss: 1.740 - lr: 9.0e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5535.1 - avg_words_per_second: 3596.7 - ETA: >2024-05-25 20:12:16 +2024-05-25 20:01:26 (UTC) - 0:34:50 - train - INFO - step: 000229 - done (%): 76.3 - loss: 1.253 - lr: 8.7e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.9 - avg_words_per_second: 3602.2 - ETA: >2024-05-25 20:12:12 +2024-05-25 20:01:44 (UTC) - 0:35:09 - train - INFO - step: 000230 - done (%): 76.7 - loss: 1.455 - lr: 8.5e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 1782.3 - avg_words_per_second: 3586.3 - ETA: >2024-05-25 20:12:24 +2024-05-25 20:01:50 (UTC) - 0:35:15 - train - INFO - step: 000231 - done (%): 77.0 - loss: 1.701 - lr: 8.3e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5596.3 - avg_words_per_second: 3591.9 - ETA: >2024-05-25 20:12:20 +2024-05-25 20:01:56 (UTC) - 0:35:20 - train - INFO - step: 000232 - done (%): 77.3 - loss: 1.405 - lr: 8.0e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5586.9 - avg_words_per_second: 3597.4 - ETA: >2024-05-25 20:12:16 +2024-05-25 20:02:02 (UTC) - 0:35:26 - train - INFO - step: 000233 - done (%): 77.7 - loss: 1.586 - lr: 7.8e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5593.7 - avg_words_per_second: 3602.9 - ETA: >2024-05-25 20:12:11 +2024-05-25 20:02:08 (UTC) - 0:35:32 - train - INFO - step: 000234 - done (%): 78.0 - loss: 1.685 - lr: 7.6e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5580.4 - avg_words_per_second: 3608.4 - ETA: >2024-05-25 20:12:07 +2024-05-25 20:02:14 (UTC) - 0:35:38 - train - INFO - step: 000235 - done (%): 78.3 - loss: 1.499 - lr: 7.4e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5560.3 - avg_words_per_second: 3613.8 - ETA: >2024-05-25 20:12:03 +2024-05-25 20:02:20 (UTC) - 0:35:44 - train - INFO - step: 000236 - done (%): 78.7 - loss: 1.609 - lr: 7.2e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5561.0 - avg_words_per_second: 3619.2 - ETA: >2024-05-25 20:11:59 +2024-05-25 20:02:26 (UTC) - 0:35:50 - train - INFO - step: 000237 - done (%): 79.0 - loss: 1.530 - lr: 6.9e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.7 - avg_words_per_second: 3624.5 - ETA: >2024-05-25 20:11:55 +2024-05-25 20:02:31 (UTC) - 0:35:56 - train - INFO - step: 000238 - done (%): 79.3 - loss: 1.255 - lr: 6.7e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.3 - avg_words_per_second: 3629.8 - ETA: >2024-05-25 20:11:51 +2024-05-25 20:02:37 (UTC) - 0:36:02 - train - INFO - step: 000239 - done (%): 79.7 - loss: 1.557 - lr: 6.5e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.7 - avg_words_per_second: 3635.1 - ETA: >2024-05-25 20:11:47 +2024-05-25 20:02:43 (UTC) - 0:36:08 - train - INFO - step: 000240 - done (%): 80.0 - loss: 1.941 - lr: 6.3e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.4 - avg_words_per_second: 3640.3 - ETA: >2024-05-25 20:11:43 +2024-05-25 20:02:49 (UTC) - 0:36:13 - train - INFO - step: 000241 - done (%): 80.3 - loss: 1.067 - lr: 6.1e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.1 - avg_words_per_second: 3645.5 - ETA: >2024-05-25 20:11:40 +2024-05-25 20:02:55 (UTC) - 0:36:19 - train - INFO - step: 000242 - done (%): 80.7 - loss: 1.181 - lr: 5.9e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.0 - avg_words_per_second: 3650.7 - ETA: >2024-05-25 20:11:36 +2024-05-25 20:03:01 (UTC) - 0:36:25 - train - INFO - step: 000243 - done (%): 81.0 - loss: 1.869 - lr: 5.7e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5551.8 - avg_words_per_second: 3655.9 - ETA: >2024-05-25 20:11:32 +2024-05-25 20:03:07 (UTC) - 0:36:31 - train - INFO - step: 000244 - done (%): 81.3 - loss: 1.208 - lr: 5.5e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.3 - avg_words_per_second: 3661.0 - ETA: >2024-05-25 20:11:28 +2024-05-25 20:03:13 (UTC) - 0:36:37 - train - INFO - step: 000245 - done (%): 81.7 - loss: 1.425 - lr: 5.3e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.0 - avg_words_per_second: 3666.1 - ETA: >2024-05-25 20:11:24 +2024-05-25 20:03:19 (UTC) - 0:36:43 - train - INFO - step: 000246 - done (%): 82.0 - loss: 1.526 - lr: 5.2e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.5 - avg_words_per_second: 3671.1 - ETA: >2024-05-25 20:11:21 +2024-05-25 20:03:25 (UTC) - 0:36:49 - train - INFO - step: 000247 - done (%): 82.3 - loss: 1.614 - lr: 5.0e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.1 - avg_words_per_second: 3676.2 - ETA: >2024-05-25 20:11:17 +2024-05-25 20:03:31 (UTC) - 0:36:55 - train - INFO - step: 000248 - done (%): 82.7 - loss: 1.349 - lr: 4.8e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5557.0 - avg_words_per_second: 3681.2 - ETA: >2024-05-25 20:11:13 +2024-05-25 20:03:36 (UTC) - 0:37:01 - train - INFO - step: 000249 - done (%): 83.0 - loss: 1.616 - lr: 4.6e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5564.7 - avg_words_per_second: 3686.2 - ETA: >2024-05-25 20:11:10 +2024-05-25 20:03:42 (UTC) - 0:37:07 - train - INFO - step: 000250 - done (%): 83.3 - loss: 1.431 - lr: 4.4e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5532.4 - avg_words_per_second: 3691.1 - ETA: >2024-05-25 20:11:06 +2024-05-25 20:03:48 (UTC) - 0:37:12 - train - INFO - step: 000251 - done (%): 83.7 - loss: 1.101 - lr: 4.3e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.3 - avg_words_per_second: 3696.1 - ETA: >2024-05-25 20:11:03 +2024-05-25 20:03:54 (UTC) - 0:37:18 - train - INFO - step: 000252 - done (%): 84.0 - loss: 1.936 - lr: 4.1e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.2 - avg_words_per_second: 3701.0 - ETA: >2024-05-25 20:10:59 +2024-05-25 20:04:00 (UTC) - 0:37:24 - train - INFO - step: 000253 - done (%): 84.3 - loss: 1.428 - lr: 3.9e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.9 - avg_words_per_second: 3705.8 - ETA: >2024-05-25 20:10:56 +2024-05-25 20:04:06 (UTC) - 0:37:30 - train - INFO - step: 000254 - done (%): 84.7 - loss: 1.442 - lr: 3.8e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5547.0 - avg_words_per_second: 3710.7 - ETA: >2024-05-25 20:10:52 +2024-05-25 20:04:12 (UTC) - 0:37:36 - train - INFO - step: 000255 - done (%): 85.0 - loss: 1.652 - lr: 3.6e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.5 - avg_words_per_second: 3715.5 - ETA: >2024-05-25 20:10:49 +2024-05-25 20:04:18 (UTC) - 0:37:42 - train - INFO - step: 000256 - done (%): 85.3 - loss: 1.313 - lr: 3.5e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5561.9 - avg_words_per_second: 3720.3 - ETA: >2024-05-25 20:10:45 +2024-05-25 20:04:24 (UTC) - 0:37:48 - train - INFO - step: 000257 - done (%): 85.7 - loss: 1.359 - lr: 3.3e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.8 - avg_words_per_second: 3725.1 - ETA: >2024-05-25 20:10:42 +2024-05-25 20:04:30 (UTC) - 0:37:54 - train - INFO - step: 000258 - done (%): 86.0 - loss: 1.539 - lr: 3.2e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.1 - avg_words_per_second: 3729.9 - ETA: >2024-05-25 20:10:39 +2024-05-25 20:04:35 (UTC) - 0:38:00 - train - INFO - step: 000259 - done (%): 86.3 - loss: 1.493 - lr: 3.0e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.5 - avg_words_per_second: 3734.6 - ETA: >2024-05-25 20:10:35 +2024-05-25 20:04:41 (UTC) - 0:38:06 - train - INFO - step: 000260 - done (%): 86.7 - loss: 1.861 - lr: 2.9e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5559.5 - avg_words_per_second: 3739.3 - ETA: >2024-05-25 20:10:32 +2024-05-25 20:04:47 (UTC) - 0:38:11 - train - INFO - step: 000261 - done (%): 87.0 - loss: 1.783 - lr: 2.7e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5550.1 - avg_words_per_second: 3744.0 - ETA: >2024-05-25 20:10:29 +2024-05-25 20:04:53 (UTC) - 0:38:17 - train - INFO - step: 000262 - done (%): 87.3 - loss: 1.310 - lr: 2.6e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5544.9 - avg_words_per_second: 3748.7 - ETA: >2024-05-25 20:10:25 +2024-05-25 20:04:59 (UTC) - 0:38:23 - train - INFO - step: 000263 - done (%): 87.7 - loss: 1.422 - lr: 2.5e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.7 - avg_words_per_second: 3753.3 - ETA: >2024-05-25 20:10:22 +2024-05-25 20:05:05 (UTC) - 0:38:29 - train - INFO - step: 000264 - done (%): 88.0 - loss: 1.603 - lr: 2.3e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5550.5 - avg_words_per_second: 3757.9 - ETA: >2024-05-25 20:10:19 +2024-05-25 20:05:11 (UTC) - 0:38:35 - train - INFO - step: 000265 - done (%): 88.3 - loss: 1.169 - lr: 2.2e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.9 - avg_words_per_second: 3762.5 - ETA: >2024-05-25 20:10:16 +2024-05-25 20:05:17 (UTC) - 0:38:41 - train - INFO - step: 000266 - done (%): 88.7 - loss: 1.044 - lr: 2.1e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5543.6 - avg_words_per_second: 3767.1 - ETA: >2024-05-25 20:10:13 +2024-05-25 20:05:23 (UTC) - 0:38:47 - train - INFO - step: 000267 - done (%): 89.0 - loss: 1.493 - lr: 2.0e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5543.9 - avg_words_per_second: 3771.6 - ETA: >2024-05-25 20:10:09 +2024-05-25 20:05:29 (UTC) - 0:38:53 - train - INFO - step: 000268 - done (%): 89.3 - loss: 1.753 - lr: 1.8e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5540.6 - avg_words_per_second: 3776.1 - ETA: >2024-05-25 20:10:06 +2024-05-25 20:05:35 (UTC) - 0:38:59 - train - INFO - step: 000269 - done (%): 89.7 - loss: 1.648 - lr: 1.7e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.4 - avg_words_per_second: 3780.6 - ETA: >2024-05-25 20:10:03 +2024-05-25 20:05:40 (UTC) - 0:39:05 - train - INFO - step: 000270 - done (%): 90.0 - loss: 1.570 - lr: 1.6e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5542.1 - avg_words_per_second: 3785.0 - ETA: >2024-05-25 20:10:00 +2024-05-25 20:05:46 (UTC) - 0:39:11 - train - INFO - step: 000271 - done (%): 90.3 - loss: 1.327 - lr: 1.5e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5557.3 - avg_words_per_second: 3789.5 - ETA: >2024-05-25 20:09:57 +2024-05-25 20:05:52 (UTC) - 0:39:16 - train - INFO - step: 000272 - done (%): 90.7 - loss: 1.483 - lr: 1.4e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.7 - avg_words_per_second: 3793.9 - ETA: >2024-05-25 20:09:54 +2024-05-25 20:05:58 (UTC) - 0:39:22 - train - INFO - step: 000273 - done (%): 91.0 - loss: 1.240 - lr: 1.3e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5547.7 - avg_words_per_second: 3798.3 - ETA: >2024-05-25 20:09:51 +2024-05-25 20:06:04 (UTC) - 0:39:28 - train - INFO - step: 000274 - done (%): 91.3 - loss: 1.845 - lr: 1.2e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5547.3 - avg_words_per_second: 3802.7 - ETA: >2024-05-25 20:09:48 +2024-05-25 20:06:10 (UTC) - 0:39:34 - train - INFO - step: 000275 - done (%): 91.7 - loss: 1.985 - lr: 1.1e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5543.7 - avg_words_per_second: 3807.0 - ETA: >2024-05-25 20:09:45 +2024-05-25 20:06:16 (UTC) - 0:39:40 - train - INFO - step: 000276 - done (%): 92.0 - loss: 1.439 - lr: 1.0e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.8 - avg_words_per_second: 3811.4 - ETA: >2024-05-25 20:09:42 +2024-05-25 20:06:22 (UTC) - 0:39:46 - train - INFO - step: 000277 - done (%): 92.3 - loss: 1.516 - lr: 9.6e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5535.4 - avg_words_per_second: 3815.7 - ETA: >2024-05-25 20:09:39 +2024-05-25 20:06:28 (UTC) - 0:39:52 - train - INFO - step: 000278 - done (%): 92.7 - loss: 1.325 - lr: 8.8e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5545.9 - avg_words_per_second: 3820.0 - ETA: >2024-05-25 20:09:36 +2024-05-25 20:06:34 (UTC) - 0:39:58 - train - INFO - step: 000279 - done (%): 93.0 - loss: 1.802 - lr: 8.0e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.1 - avg_words_per_second: 3824.2 - ETA: >2024-05-25 20:09:34 +2024-05-25 20:06:40 (UTC) - 0:40:04 - train - INFO - step: 000280 - done (%): 93.3 - loss: 1.204 - lr: 7.3e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.6 - avg_words_per_second: 3828.5 - ETA: >2024-05-25 20:09:31 +2024-05-25 20:06:45 (UTC) - 0:40:10 - train - INFO - step: 000281 - done (%): 93.7 - loss: 1.335 - lr: 6.6e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.0 - avg_words_per_second: 3832.7 - ETA: >2024-05-25 20:09:28 +2024-05-25 20:06:51 (UTC) - 0:40:16 - train - INFO - step: 000282 - done (%): 94.0 - loss: 1.258 - lr: 5.9e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.5 - avg_words_per_second: 3836.9 - ETA: >2024-05-25 20:09:25 +2024-05-25 20:06:57 (UTC) - 0:40:21 - train - INFO - step: 000283 - done (%): 94.3 - loss: 2.084 - lr: 5.3e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.1 - avg_words_per_second: 3841.1 - ETA: >2024-05-25 20:09:22 +2024-05-25 20:07:03 (UTC) - 0:40:27 - train - INFO - step: 000284 - done (%): 94.7 - loss: 1.553 - lr: 4.7e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.4 - avg_words_per_second: 3845.3 - ETA: >2024-05-25 20:09:19 +2024-05-25 20:07:09 (UTC) - 0:40:33 - train - INFO - step: 000285 - done (%): 95.0 - loss: 1.579 - lr: 4.1e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5534.1 - avg_words_per_second: 3849.4 - ETA: >2024-05-25 20:09:17 +2024-05-25 20:07:15 (UTC) - 0:40:39 - train - INFO - step: 000286 - done (%): 95.3 - loss: 1.404 - lr: 3.6e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5566.5 - avg_words_per_second: 3853.6 - ETA: >2024-05-25 20:09:14 +2024-05-25 20:07:21 (UTC) - 0:40:45 - train - INFO - step: 000287 - done (%): 95.7 - loss: 1.632 - lr: 3.1e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.8 - avg_words_per_second: 3857.7 - ETA: >2024-05-25 20:09:11 +2024-05-25 20:07:27 (UTC) - 0:40:51 - train - INFO - step: 000288 - done (%): 96.0 - loss: 1.673 - lr: 2.6e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.8 - avg_words_per_second: 3861.8 - ETA: >2024-05-25 20:09:09 +2024-05-25 20:07:33 (UTC) - 0:40:57 - train - INFO - step: 000289 - done (%): 96.3 - loss: 1.946 - lr: 2.2e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.2 - avg_words_per_second: 3865.8 - ETA: >2024-05-25 20:09:06 +2024-05-25 20:07:39 (UTC) - 0:41:03 - train - INFO - step: 000290 - done (%): 96.7 - loss: 1.794 - lr: 1.8e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5547.1 - avg_words_per_second: 3869.9 - ETA: >2024-05-25 20:09:03 +2024-05-25 20:07:44 (UTC) - 0:41:09 - train - INFO - step: 000291 - done (%): 97.0 - loss: 1.643 - lr: 1.5e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.7 - avg_words_per_second: 3873.9 - ETA: >2024-05-25 20:09:01 +2024-05-25 20:07:50 (UTC) - 0:41:15 - train - INFO - step: 000292 - done (%): 97.3 - loss: 1.307 - lr: 1.2e-07 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5545.3 - avg_words_per_second: 3877.9 - ETA: >2024-05-25 20:08:58 +2024-05-25 20:07:56 (UTC) - 0:41:21 - train - INFO - step: 000293 - done (%): 97.7 - loss: 1.458 - lr: 9.0e-08 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.3 - avg_words_per_second: 3881.9 - ETA: >2024-05-25 20:08:55 +2024-05-25 20:08:02 (UTC) - 0:41:26 - train - INFO - step: 000294 - done (%): 98.0 - loss: 1.914 - lr: 6.6e-08 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.7 - avg_words_per_second: 3885.9 - ETA: >2024-05-25 20:08:53 +2024-05-25 20:08:08 (UTC) - 0:41:32 - train - INFO - step: 000295 - done (%): 98.3 - loss: 1.580 - lr: 4.6e-08 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5534.9 - avg_words_per_second: 3889.8 - ETA: >2024-05-25 20:08:50 +2024-05-25 20:08:14 (UTC) - 0:41:38 - train - INFO - step: 000296 - done (%): 98.7 - loss: 1.180 - lr: 2.9e-08 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.1 - avg_words_per_second: 3893.7 - ETA: >2024-05-25 20:08:48 +2024-05-25 20:08:20 (UTC) - 0:41:44 - train - INFO - step: 000297 - done (%): 99.0 - loss: 1.492 - lr: 1.7e-08 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5536.1 - avg_words_per_second: 3897.6 - ETA: >2024-05-25 20:08:45 +2024-05-25 20:08:26 (UTC) - 0:41:50 - train - INFO - step: 000298 - done (%): 99.3 - loss: 1.943 - lr: 7.5e-09 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5545.8 - avg_words_per_second: 3901.5 - ETA: >2024-05-25 20:08:43 +2024-05-25 20:08:32 (UTC) - 0:41:56 - train - INFO - step: 000299 - done (%): 99.7 - loss: 1.854 - lr: 2.1e-09 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5520.7 - avg_words_per_second: 3905.4 - ETA: >2024-05-25 20:08:40 +2024-05-25 20:08:38 (UTC) - 0:42:02 - train - INFO - step: 000300 - done (%): 100.0 - loss: 1.580 - lr: 2.4e-10 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5557.3 - avg_words_per_second: 3909.2 - ETA: >2024-05-25 20:08:38 +2024-05-25 20:08:38 (UTC) - 0:42:02 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runs/checkpoints/checkpoint_000300/consolidated using tmp name: tmp.consolidated +2024-05-25 20:08:38 (UTC) - 0:42:02 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runs/checkpoints/checkpoint_000300/consolidated for step: 300 +2024-05-25 20:08:38 (UTC) - 0:42:02 - checkpointing - INFO - Done deleting checkpoints +2024-05-25 20:08:38 (UTC) - 0:42:02 - checkpointing - INFO - Done! +2024-05-25 20:08:38 (UTC) - 0:42:02 - train - INFO - done! +2024-05-25 20:08:38 (UTC) - 0:42:02 - utils - INFO - Closing: eval_logger \ No newline at end of file diff --git a/runs/wandb/run-20240525_192638-zf4t8z6a/files/requirements.txt b/runs/wandb/run-20240525_192638-zf4t8z6a/files/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..f173be0be357b3fd62b7aba8d8c38a23b90cdc07 --- /dev/null +++ b/runs/wandb/run-20240525_192638-zf4t8z6a/files/requirements.txt @@ -0,0 +1,67 @@ +GitPython==3.1.43 +Jinja2==3.1.4 +Markdown==3.6 +MarkupSafe==2.1.5 +PyYAML==6.0.1 +Werkzeug==3.0.3 +absl-py==2.1.0 +annotated-types==0.7.0 +attrs==23.2.0 +certifi==2024.2.2 +charset-normalizer==3.3.2 +click==8.1.7 +docker-pycreds==0.4.0 +docstring_parser==0.16 +filelock==3.14.0 +fire==0.6.0 +fsspec==2024.5.0 +gitdb==4.0.11 +grpcio==1.64.0 +idna==3.7 +jsonschema-specifications==2023.12.1 +jsonschema==4.21.1 +mistral_common==1.1.0 +mpmath==1.3.0 +networkx==3.3 +numpy==1.26.4 +nvidia-cublas-cu12==12.1.3.1 +nvidia-cuda-cupti-cu12==12.1.105 +nvidia-cuda-nvrtc-cu12==12.1.105 +nvidia-cuda-runtime-cu12==12.1.105 +nvidia-cudnn-cu12==8.9.2.26 +nvidia-cufft-cu12==11.0.2.54 +nvidia-curand-cu12==10.3.2.106 +nvidia-cusolver-cu12==11.4.5.107 +nvidia-cusparse-cu12==12.1.0.106 +nvidia-nccl-cu12==2.19.3 +nvidia-nvjitlink-cu12==12.5.40 +nvidia-nvtx-cu12==12.1.105 +pip==24.0 +platformdirs==4.2.2 +protobuf==4.25.3 +psutil==5.9.8 +pydantic==2.6.1 +pydantic_core==2.16.2 +referencing==0.35.1 +requests==2.32.2 +rpds-py==0.18.1 +safetensors==0.4.3 +sentencepiece==0.1.99 +sentry-sdk==2.3.1 +setproctitle==1.3.3 +setuptools==69.5.1 +simple_parsing==0.1.5 +six==1.16.0 +smmap==5.0.1 +sympy==1.12 +tensorboard-data-server==0.7.2 +tensorboard==2.16.2 +termcolor==2.4.0 +torch==2.2.0 +tqdm==4.66.4 +triton==2.2.0 +typing_extensions==4.12.0 +urllib3==2.2.1 +wandb==0.17.0 +wheel==0.43.0 +xformers==0.0.24 \ No newline at end of file diff --git a/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-metadata.json b/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..87001171430f869b45ec0841c0bc0578045d7f8a --- /dev/null +++ b/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-metadata.json @@ -0,0 +1,169 @@ +{ + "os": "Linux-5.15.0-102-generic-x86_64-with-glibc2.35", + "python": "3.10.14", + "heartbeatAt": "2024-05-25T19:26:39.119542", + "startedAt": "2024-05-25T19:26:38.715184", + "docker": null, + "cuda": null, + "args": [ + "example/7B.yaml" + ], + "state": "running", + "program": "-m train", + "codePathLocal": null, + "git": { + "remote": "https://github.com/mistralai/mistral-finetune.git", + "commit": "cb892f012ef940bc741dd3b043bc1d06f0cf6085" + }, + "email": "clement.castellon@gmail.com", + "root": "/root/mistral-finetune", + "host": "scw-tender-archimedes", + "username": "root", + "executable": "/root/miniconda/envs/chemistralpy310/bin/python", + "cpu_count": 24, + "cpu_count_logical": 24, + "cpu_freq": { + "current": 2699.9959999999996, + "min": 0.0, + "max": 0.0 + }, + "cpu_freq_per_core": [ + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + } + ], + "disk": { + "/": { + "total": 902.4293403625488, + "used": 149.24076461791992 + } + }, + "gpu": "NVIDIA H100 PCIe", + "gpu_count": 1, + "gpu_devices": [ + { + "name": "NVIDIA H100 PCIe", + "memory_total": 85520809984 + } + ], + "memory": { + "total": 235.9408187866211 + } +} diff --git a/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json b/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json new file mode 100644 index 0000000000000000000000000000000000000000..d88f2211bd9907bc65ec767160f8c6958aa43b37 --- /dev/null +++ b/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json @@ -0,0 +1 @@ +{"train/lr": 2.4e-10, "train/loss": 1.5795124769210815, "train/percent_done": 100.0, "train/peak_allocated_mem": 40.3391375541687, "train/allocated_mem": 20.14026165008545, "train/wps": 5557.2905653761345, "train/avg_wps": 3909.2261012039853, "train/eta_in_seconds": 0.0, "_timestamp": 1716667718.1957629, "_runtime": 2519.478351831436, "_step": 300, "_wandb": {"runtime": 2519}} \ No newline at end of file diff --git a/runs/wandb/run-20240525_192638-zf4t8z6a/logs/debug-internal.log b/runs/wandb/run-20240525_192638-zf4t8z6a/logs/debug-internal.log new file mode 100644 index 0000000000000000000000000000000000000000..1852431f302959f2dc4b2c926308c2a76f04b29f --- /dev/null +++ b/runs/wandb/run-20240525_192638-zf4t8z6a/logs/debug-internal.log @@ -0,0 +1,2844 @@ +2024-05-25 19:26:38,718 INFO StreamThr :27237 [internal.py:wandb_internal():85] W&B internal server running at pid: 27237, started at: 2024-05-25 19:26:38.717602 +2024-05-25 19:26:38,718 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status +2024-05-25 19:26:38,720 INFO WriterThread:27237 [datastore.py:open_for_write():87] open: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/run-zf4t8z6a.wandb +2024-05-25 19:26:38,721 DEBUG SenderThread:27237 [sender.py:send():378] send: header +2024-05-25 19:26:38,721 DEBUG SenderThread:27237 [sender.py:send():378] send: run +2024-05-25 19:26:39,024 INFO SenderThread:27237 [dir_watcher.py:__init__():211] watching files in: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files +2024-05-25 19:26:39,024 INFO SenderThread:27237 [sender.py:_start_run_threads():1123] run started: zf4t8z6a with start time 1716665198.717411 +2024-05-25 19:26:39,029 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: check_version +2024-05-25 19:26:39,029 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: check_version +2024-05-25 19:26:39,102 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: run_start +2024-05-25 19:26:39,107 DEBUG HandlerThread:27237 [system_info.py:__init__():26] System info init +2024-05-25 19:26:39,107 DEBUG HandlerThread:27237 [system_info.py:__init__():41] System info init done +2024-05-25 19:26:39,107 INFO HandlerThread:27237 [system_monitor.py:start():194] Starting system monitor +2024-05-25 19:26:39,107 INFO SystemMonitor:27237 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-05-25 19:26:39,107 INFO HandlerThread:27237 [system_monitor.py:probe():214] Collecting system info +2024-05-25 19:26:39,108 INFO SystemMonitor:27237 [interfaces.py:start():188] Started cpu monitoring +2024-05-25 19:26:39,109 INFO SystemMonitor:27237 [interfaces.py:start():188] Started disk monitoring +2024-05-25 19:26:39,110 INFO SystemMonitor:27237 [interfaces.py:start():188] Started gpu monitoring +2024-05-25 19:26:39,111 INFO SystemMonitor:27237 [interfaces.py:start():188] Started memory monitoring +2024-05-25 19:26:39,111 INFO SystemMonitor:27237 [interfaces.py:start():188] Started network monitoring +2024-05-25 19:26:39,119 DEBUG HandlerThread:27237 [system_info.py:probe():150] Probing system +2024-05-25 19:26:39,120 DEBUG HandlerThread:27237 [system_info.py:_probe_git():135] Probing git +2024-05-25 19:26:39,123 DEBUG HandlerThread:27237 [system_info.py:_probe_git():143] Probing git done +2024-05-25 19:26:39,123 DEBUG HandlerThread:27237 [system_info.py:probe():198] Probing system done +2024-05-25 19:26:39,123 DEBUG HandlerThread:27237 [system_monitor.py:probe():223] {'os': 'Linux-5.15.0-102-generic-x86_64-with-glibc2.35', 'python': '3.10.14', 'heartbeatAt': '2024-05-25T19:26:39.119542', 'startedAt': '2024-05-25T19:26:38.715184', 'docker': None, 'cuda': None, 'args': ('example/7B.yaml',), 'state': 'running', 'program': '-m train', 'codePathLocal': None, 'git': {'remote': 'https://github.com/mistralai/mistral-finetune.git', 'commit': 'cb892f012ef940bc741dd3b043bc1d06f0cf6085'}, 'email': 'clement.castellon@gmail.com', 'root': '/root/mistral-finetune', 'host': 'scw-tender-archimedes', 'username': 'root', 'executable': '/root/miniconda/envs/chemistralpy310/bin/python', 'cpu_count': 24, 'cpu_count_logical': 24, 'cpu_freq': {'current': 2699.9959999999996, 'min': 0.0, 'max': 0.0}, 'cpu_freq_per_core': [{'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}], 'disk': {'/': {'total': 902.4293403625488, 'used': 149.24076461791992}}, 'gpu': 'NVIDIA H100 PCIe', 'gpu_count': 1, 'gpu_devices': [{'name': 'NVIDIA H100 PCIe', 'memory_total': 85520809984}], 'memory': {'total': 235.9408187866211}} +2024-05-25 19:26:39,123 INFO HandlerThread:27237 [system_monitor.py:probe():224] Finished collecting system info +2024-05-25 19:26:39,124 INFO HandlerThread:27237 [system_monitor.py:probe():227] Publishing system info +2024-05-25 19:26:39,124 DEBUG HandlerThread:27237 [system_info.py:_save_conda():207] Saving list of conda packages installed into the current environment +2024-05-25 19:26:40,025 INFO Thread-12 :27237 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/conda-environment.yaml +2024-05-25 19:26:40,039 DEBUG HandlerThread:27237 [system_info.py:_save_conda():222] Saving conda packages done +2024-05-25 19:26:40,039 INFO HandlerThread:27237 [system_monitor.py:probe():229] Finished publishing system info +2024-05-25 19:26:40,041 DEBUG SenderThread:27237 [sender.py:send():378] send: files +2024-05-25 19:26:40,042 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-metadata.json with policy now +2024-05-25 19:26:40,070 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: python_packages +2024-05-25 19:26:40,070 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: python_packages +2024-05-25 19:26:40,070 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:26:40,070 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:26:40,246 DEBUG SenderThread:27237 [sender.py:send():378] send: telemetry +2024-05-25 19:26:40,496 INFO wandb-upload_0:27237 [upload_job.py:push():130] Uploaded file /tmp/tmppgb4391mwandb/ms7pal7a-wandb-metadata.json +2024-05-25 19:26:41,025 INFO Thread-12 :27237 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:26:41,025 INFO Thread-12 :27237 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-metadata.json +2024-05-25 19:26:41,025 INFO Thread-12 :27237 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/requirements.txt +2024-05-25 19:26:43,025 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:26:44,451 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:26:45,026 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:26:49,452 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:26:54,452 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:26:55,102 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:26:55,102 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:27:00,327 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:27:05,328 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:27:10,127 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:27:10,127 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:27:11,268 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:27:12,033 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/config.yaml +2024-05-25 19:27:16,400 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:27:21,400 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:27:25,117 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:27:25,117 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:27:27,292 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:27:32,292 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:27:37,293 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:27:39,112 DEBUG SystemMonitor:27237 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-05-25 19:27:39,113 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:27:40,122 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:27:40,122 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:27:43,266 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:27:48,266 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:27:53,267 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:27:55,133 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:27:55,133 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:27:58,328 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:28:03,329 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:28:08,329 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:28:09,113 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:28:10,166 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:28:10,166 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:28:14,312 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:28:19,312 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:28:24,313 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:28:25,167 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:28:25,167 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:28:29,401 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:28:34,402 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:28:39,114 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:28:40,114 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:28:40,155 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:28:40,155 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:28:45,376 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:28:50,377 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:28:55,170 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:28:55,170 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:28:56,359 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:29:01,360 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:29:06,360 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:29:09,114 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:29:10,163 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:29:10,163 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:29:11,375 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:29:16,376 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:29:21,377 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:29:25,185 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:29:25,185 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:29:27,328 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:29:32,329 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:29:37,330 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:29:39,115 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:29:40,179 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:29:40,179 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:29:42,387 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:29:47,387 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:29:52,388 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:29:55,184 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:29:55,184 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:29:58,364 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:30:03,364 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:30:08,365 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:30:09,115 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:30:10,195 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:30:10,195 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:30:13,366 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:30:18,367 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:30:23,367 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:30:25,231 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:30:25,231 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:30:28,407 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:30:33,408 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:30:38,409 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:30:39,116 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:30:40,200 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:30:40,200 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:30:44,383 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:30:49,383 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:30:54,384 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:30:56,374 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:30:56,374 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:30:59,555 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:31:04,555 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:31:09,116 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:31:10,117 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:31:11,416 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:31:11,416 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:31:15,615 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:31:20,616 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:31:25,616 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:31:26,448 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:31:26,449 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:31:31,592 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:31:36,592 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:31:39,117 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:31:41,422 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:31:41,422 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:31:41,640 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:31:46,640 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:31:51,641 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:31:56,390 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:31:56,390 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:31:57,605 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:32:02,606 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:32:07,607 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:32:09,117 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:32:11,407 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:32:11,407 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:32:13,605 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:32:18,606 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:32:23,607 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:32:26,391 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:32:26,392 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:32:29,534 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:32:34,535 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:32:39,118 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:32:40,118 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:32:41,412 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:32:41,412 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:32:45,627 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:32:50,627 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:32:55,628 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:32:56,449 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:32:56,449 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:33:01,610 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:33:06,610 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:33:09,118 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:33:11,474 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:33:11,475 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:33:11,685 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:33:16,686 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:33:21,686 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:33:26,454 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:33:26,454 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:33:27,651 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:33:32,652 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:33:37,653 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:33:39,118 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:33:41,423 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:33:41,423 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:33:43,550 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:33:48,551 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:33:53,551 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:33:56,443 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:33:56,443 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:33:58,645 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:34:03,645 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:34:08,646 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:34:09,119 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:34:11,433 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:34:11,433 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:34:14,634 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:34:19,634 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:34:24,635 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:34:26,460 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:34:26,460 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:34:29,664 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:34:34,665 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:34:39,119 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:34:40,120 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:34:41,470 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:34:41,470 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:34:45,654 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:34:50,654 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:34:55,655 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:34:56,486 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:34:56,486 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:35:00,711 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:35:05,712 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:35:09,120 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:35:11,120 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:35:11,459 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:35:11,459 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:35:16,591 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:35:21,592 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:35:26,502 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:35:26,503 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:35:26,735 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:35:31,736 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:35:36,737 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:35:39,120 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:35:41,475 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:35:41,475 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:35:42,714 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:35:47,715 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:35:52,716 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:35:56,495 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:35:56,496 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:35:58,652 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:36:03,653 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:36:08,653 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:36:09,121 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:36:11,521 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:36:11,521 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:36:13,763 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:36:18,764 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:36:23,764 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:36:28,082 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:36:28,082 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:36:29,221 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:36:34,221 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:36:39,121 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:36:40,122 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:36:43,093 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:36:43,093 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:36:45,342 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:36:50,343 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:36:55,343 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:36:58,093 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:36:58,093 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:37:01,269 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:37:06,269 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:37:09,122 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:37:12,122 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:37:13,093 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:37:13,093 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:37:17,264 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:37:22,264 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:37:27,265 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:37:28,135 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:37:28,135 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:37:32,284 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:37:37,285 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:37:39,127 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:37:43,098 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:37:43,119 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:37:43,119 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:37:48,289 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:37:53,290 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:37:58,124 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:37:58,124 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:37:58,327 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:38:03,328 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:38:08,328 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:38:09,123 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:38:13,108 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:38:13,109 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:38:14,310 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:38:19,311 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:38:24,311 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:38:28,124 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:38:28,125 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:38:30,302 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:38:35,302 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:38:39,123 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:38:41,124 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:38:43,151 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:38:43,151 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:38:45,208 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:38:46,374 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:38:50,622 DEBUG SenderThread:27237 [sender.py:send():378] send: telemetry +2024-05-25 19:38:50,622 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:38:51,622 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:38:53,210 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:38:56,366 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:38:56,367 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:38:56,367 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:38:56,368 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:38:57,211 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:38:57,211 INFO Thread-12 :27237 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:38:57,368 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:38:58,113 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:38:58,114 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:39:02,163 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:39:02,163 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:39:02,163 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:39:02,164 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:39:02,212 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:39:03,164 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:39:03,212 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:39:07,962 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:39:07,963 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:39:07,963 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:39:07,963 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:39:08,213 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:39:08,964 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:39:09,124 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:39:09,214 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:39:13,114 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:39:13,114 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:39:13,783 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:39:13,784 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:39:13,784 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:39:13,784 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:39:14,215 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:39:14,787 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:39:15,215 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:39:15,215 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/config.yaml +2024-05-25 19:39:19,616 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:39:19,616 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:39:19,617 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:39:19,617 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:39:20,216 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:39:20,617 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:39:21,216 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:39:25,468 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:39:25,469 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:39:25,469 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:39:25,469 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:39:26,217 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:39:26,469 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:39:27,218 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:39:28,114 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:39:28,114 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:39:31,319 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:39:31,319 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:39:31,320 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:39:31,320 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:39:32,219 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:39:32,320 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:39:33,219 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:39:37,172 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:39:37,173 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:39:37,173 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:39:37,173 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:39:37,220 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:39:38,173 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:39:39,124 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:39:39,220 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:39:43,043 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:39:43,044 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:39:43,044 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:39:43,044 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:39:43,114 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:39:43,114 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:39:43,221 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:39:43,241 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:39:45,222 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:39:48,241 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:39:48,932 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:39:48,933 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:39:48,933 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:39:48,933 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:39:49,223 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:39:51,224 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:39:53,934 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:39:54,831 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:39:54,831 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:39:54,831 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:39:54,832 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:39:55,225 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:39:57,225 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:39:58,114 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:39:58,114 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:39:59,258 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:40:00,710 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:40:00,710 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:40:00,711 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:40:00,711 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:40:01,226 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:40:03,227 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:40:04,711 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:40:06,589 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:40:06,590 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:40:06,590 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:40:06,590 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:40:07,228 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:40:07,228 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:40:09,125 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:40:10,125 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:40:12,484 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:40:12,484 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:40:12,485 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:40:12,485 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:40:13,114 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:40:13,114 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:40:13,230 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:40:13,230 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:40:15,322 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:40:18,380 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:40:18,380 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:40:18,381 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:40:18,381 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:40:19,231 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:40:19,232 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:40:20,381 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:40:24,287 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:40:24,288 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:40:24,288 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:40:24,288 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:40:25,233 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:40:25,233 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:40:26,289 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:40:28,114 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:40:28,115 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:40:30,186 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:40:30,186 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:40:30,186 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:40:30,187 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:40:30,234 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:40:31,235 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:40:32,187 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:40:36,078 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:40:36,079 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:40:36,079 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:40:36,079 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:40:36,236 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:40:37,236 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:40:38,080 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:40:39,125 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:40:41,978 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:40:41,979 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:40:41,979 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:40:41,980 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:40:42,237 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:40:43,114 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:40:43,115 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:40:43,238 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:40:43,306 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:40:47,874 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:40:47,875 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:40:47,875 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:40:47,875 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:40:48,239 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:40:48,875 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:40:50,240 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:40:53,773 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:40:53,774 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:40:53,774 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:40:53,774 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:40:54,241 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:40:54,774 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:40:56,242 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:40:58,114 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:40:58,115 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:40:59,679 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:40:59,680 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:40:59,680 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:40:59,680 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:41:00,243 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:41:00,680 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:41:02,243 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:41:05,589 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:41:05,589 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:41:05,589 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:41:05,590 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:41:06,244 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:41:06,590 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:41:08,245 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:41:09,126 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:41:11,496 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:41:11,497 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:41:11,497 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:41:11,497 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:41:12,246 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:41:12,498 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:41:13,115 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:41:13,115 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:41:14,246 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:41:17,398 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:41:17,398 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:41:17,398 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:41:17,399 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:41:18,247 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:41:18,399 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:41:20,248 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:41:23,305 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:41:23,305 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:41:23,305 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:41:23,305 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:41:24,249 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:41:24,306 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:41:26,250 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:41:28,115 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:41:28,115 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:41:29,211 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:41:29,212 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:41:29,212 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:41:29,212 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:41:29,251 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:41:30,213 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:41:32,251 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:41:35,119 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:41:35,123 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:41:35,124 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:41:35,124 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:41:35,252 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:41:36,124 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:41:38,253 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:41:39,126 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:41:41,031 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:41:41,032 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:41:41,032 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:41:41,032 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:41:41,254 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:41:42,032 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:41:43,115 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:41:43,115 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:41:44,255 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:41:46,932 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:41:46,933 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:41:46,933 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:41:46,933 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:41:47,256 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:41:47,934 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:41:48,256 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:41:52,831 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:41:52,832 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:41:52,832 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:41:52,833 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:41:53,258 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:41:53,833 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:41:54,258 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:41:58,115 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:41:58,115 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:41:58,739 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:41:58,739 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:41:58,740 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:41:58,740 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:41:59,259 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:41:59,740 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:42:00,259 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:42:04,650 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:42:04,650 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:42:04,651 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:42:04,651 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:42:05,261 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:42:05,651 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:42:06,261 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:42:09,126 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:42:10,556 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:42:10,557 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:42:10,557 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:42:10,557 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:42:11,263 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:42:11,558 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:42:12,263 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:42:13,115 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:42:13,115 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:42:16,451 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:42:16,451 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:42:16,452 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:42:16,452 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:42:17,264 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:42:17,452 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:42:18,265 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:42:22,351 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:42:22,352 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:42:22,352 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:42:22,352 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:42:23,266 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:42:23,353 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:42:24,266 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:42:28,115 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:42:28,116 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:42:28,256 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:42:28,259 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:42:28,260 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:42:28,260 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:42:28,267 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:42:29,260 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:42:30,268 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:42:34,218 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:42:34,219 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:42:34,219 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:42:34,219 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:42:34,269 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:42:35,219 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:42:36,269 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:42:39,127 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:42:40,084 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:42:40,085 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:42:40,085 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:42:40,085 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:42:40,270 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:42:41,085 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:42:42,271 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:42:43,115 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:42:43,116 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:42:46,009 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:42:46,009 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:42:46,009 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:42:46,010 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:42:46,272 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:42:47,010 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:42:48,272 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:42:51,931 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:42:51,931 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:42:51,932 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:42:51,932 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:42:52,273 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:42:52,932 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:42:54,274 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:42:57,830 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:42:57,831 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:42:57,831 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:42:57,831 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:42:58,115 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:42:58,116 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:42:58,266 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:42:58,275 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:43:00,275 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:43:03,266 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:43:03,734 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:43:03,735 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:43:03,735 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:43:03,736 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:43:04,276 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:43:06,277 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:43:08,736 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:43:09,127 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:43:09,639 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:43:09,640 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:43:09,640 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:43:09,640 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:43:10,278 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:43:12,278 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:43:13,116 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:43:13,116 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:43:14,271 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:43:15,550 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:43:15,551 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:43:15,551 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:43:15,551 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:43:16,279 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:43:18,280 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:43:19,552 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:43:21,462 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:43:21,462 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:43:21,463 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:43:21,463 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:43:22,296 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:43:24,297 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:43:25,463 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:43:27,367 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:43:27,368 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:43:27,368 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:43:27,369 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:43:28,116 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:43:28,116 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:43:28,298 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:43:28,298 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:43:31,328 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:43:33,272 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:43:33,273 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:43:33,273 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:43:33,273 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:43:33,299 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:43:34,299 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:43:37,274 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:43:39,128 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:43:39,196 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:43:39,197 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:43:39,197 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:43:39,197 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:43:39,300 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:43:40,300 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:43:43,116 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:43:43,116 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:43:43,336 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:43:45,100 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:43:45,101 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:43:45,101 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:43:45,101 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:43:45,302 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:43:46,302 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:43:49,102 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:43:51,013 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:43:51,014 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:43:51,014 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:43:51,014 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:43:51,303 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:43:52,303 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:43:55,015 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:43:56,925 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:43:56,926 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:43:56,926 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:43:56,926 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:43:57,304 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:43:58,116 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:43:58,116 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:43:58,305 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:44:00,328 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:44:02,860 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:44:02,860 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:44:02,861 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:44:02,861 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:44:03,306 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:44:04,306 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:44:05,862 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:44:08,771 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:44:08,772 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:44:08,772 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:44:08,772 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:44:09,128 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:44:09,307 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:44:10,308 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:44:11,129 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:44:13,116 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:44:13,116 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:44:14,696 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:44:14,697 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:44:14,697 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:44:14,697 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:44:15,309 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:44:16,309 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:44:16,698 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:44:20,606 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:44:20,607 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:44:20,607 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:44:20,607 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:44:21,310 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:44:22,311 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:44:22,608 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:44:26,537 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:44:26,537 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:44:26,537 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:44:26,538 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:44:27,312 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:44:28,116 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:44:28,117 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:44:28,242 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:44:28,312 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:44:32,435 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:44:32,436 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:44:32,436 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:44:32,436 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:44:33,313 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:44:33,437 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:44:34,314 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:44:38,341 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:44:38,342 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:44:38,342 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:44:38,342 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:44:39,134 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:44:39,135 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:44:39,315 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:44:40,315 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:44:43,116 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:44:43,117 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:44:44,260 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:44:44,260 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:44:44,260 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:44:44,261 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:44:44,261 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:44:44,316 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:44:46,317 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:44:49,262 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:44:50,192 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:44:50,193 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:44:50,193 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:44:50,193 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:44:50,318 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:44:52,318 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:44:55,194 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:44:56,099 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:44:56,099 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:44:56,100 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:44:56,100 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:44:56,319 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:44:58,116 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:44:58,117 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:44:58,320 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:45:00,290 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:45:02,006 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:45:02,007 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:45:02,007 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:45:02,007 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:45:02,321 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:45:04,321 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:45:06,008 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:45:07,910 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:45:07,910 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:45:07,911 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:45:07,911 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:45:08,322 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:45:09,130 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:45:10,323 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:45:11,130 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:45:13,117 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:45:13,117 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:45:13,810 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:45:13,811 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:45:13,811 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:45:13,812 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:45:14,324 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:45:16,324 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:45:16,812 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:45:19,729 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:45:19,730 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:45:19,730 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:45:19,730 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:45:20,325 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:45:22,326 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:45:22,731 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:45:25,632 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:45:25,633 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:45:25,633 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:45:25,633 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:45:26,326 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:45:28,117 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:45:28,117 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:45:28,248 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:45:28,327 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:45:31,538 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:45:31,539 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:45:31,539 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:45:31,539 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:45:32,328 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:45:32,328 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:45:33,540 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:45:37,429 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:45:37,429 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:45:37,429 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:45:37,430 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:45:38,329 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:45:38,330 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:45:39,130 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:45:39,130 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:45:43,117 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:45:43,117 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:45:43,323 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:45:43,324 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:45:43,324 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:45:43,325 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:45:43,331 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:45:44,325 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:45:44,331 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:45:49,230 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:45:49,231 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:45:49,231 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:45:49,231 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:45:49,332 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:45:50,232 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:45:50,332 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:45:55,121 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:45:55,122 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:45:55,122 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:45:55,122 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:45:55,333 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:45:56,123 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:45:56,333 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:45:58,117 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:45:58,117 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:46:01,033 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:46:01,034 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:46:01,034 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:46:01,034 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:46:01,335 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:46:02,035 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:46:02,335 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:46:06,926 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:46:06,927 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:46:06,927 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:46:06,927 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:46:07,336 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:46:07,928 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:46:08,336 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:46:09,131 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:46:12,814 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:46:12,815 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:46:12,815 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:46:12,815 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:46:13,117 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:46:13,117 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:46:13,257 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:46:13,337 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:46:14,338 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:46:18,257 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:46:18,713 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:46:18,713 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:46:18,714 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:46:18,714 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:46:19,339 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:46:20,339 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:46:23,715 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:46:24,622 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:46:24,622 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:46:24,622 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:46:24,622 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:46:25,340 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:46:26,340 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:46:28,117 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:46:28,118 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:46:29,356 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:46:30,530 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:46:30,531 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:46:30,531 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:46:30,531 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:46:31,342 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:46:32,342 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:46:34,532 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:46:36,415 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:46:36,416 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:46:36,416 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:46:36,416 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:46:37,343 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:46:38,343 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:46:39,131 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:46:40,132 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:46:42,304 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:46:42,304 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:46:42,304 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:46:42,305 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:46:42,345 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:46:43,117 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:46:43,118 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:46:44,345 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:46:45,274 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:46:48,198 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:46:48,199 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:46:48,199 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:46:48,200 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:46:48,346 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:46:50,347 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:46:51,200 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:46:54,092 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:46:54,092 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:46:54,092 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:46:54,093 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:46:54,348 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:46:56,348 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:46:57,093 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:46:58,117 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:46:58,118 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:46:59,978 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:46:59,979 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:46:59,979 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:46:59,979 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:47:00,349 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:47:02,350 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:47:02,980 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:47:05,872 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:47:05,872 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:47:05,872 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:47:05,873 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:47:06,350 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:47:08,351 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:47:08,873 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:47:09,131 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:47:11,761 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:47:11,761 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:47:11,762 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:47:11,762 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:47:12,352 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:47:13,118 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:47:13,118 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:47:14,307 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:47:14,352 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:47:17,644 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:47:17,645 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:47:17,645 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:47:17,645 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:47:18,353 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:47:18,354 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:47:19,645 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:47:23,531 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:47:23,532 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:47:23,532 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:47:23,532 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:47:24,355 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:47:24,355 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:47:25,533 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:47:28,118 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:47:28,118 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:47:29,425 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:47:29,426 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:47:29,426 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:47:29,426 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:47:30,356 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:47:30,356 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:47:31,426 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:47:35,345 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:47:35,345 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:47:35,345 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:47:35,346 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:47:35,357 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:47:36,358 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:47:37,346 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:47:39,132 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:47:41,229 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:47:41,229 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:47:41,230 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:47:41,230 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:47:41,359 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:47:42,359 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:47:43,118 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:47:43,118 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:47:43,244 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:47:47,149 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:47:47,153 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:47:47,153 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:47:47,154 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:47:47,360 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:47:48,360 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:47:49,155 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:47:53,038 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:47:53,038 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:47:53,039 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:47:53,039 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:47:53,362 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:47:54,362 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:47:55,039 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:47:58,118 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:47:58,118 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:47:58,942 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:47:58,943 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:47:58,943 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:47:58,943 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:47:59,363 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:48:00,363 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:48:00,944 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:48:04,836 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:48:04,837 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:48:04,837 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:48:04,837 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:48:05,365 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:48:06,365 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:48:06,837 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:48:09,133 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:48:10,733 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:48:10,734 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:48:10,734 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:48:10,734 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:48:11,366 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:48:12,366 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:48:12,735 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:48:13,118 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:48:13,118 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:48:16,619 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:48:16,620 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:48:16,620 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:48:16,620 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:48:17,368 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:48:18,368 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:48:18,621 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:48:22,512 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:48:22,512 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:48:22,513 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:48:22,513 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:48:23,369 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:48:24,370 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:48:24,514 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:48:28,118 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:48:28,119 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:48:28,403 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:48:28,404 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:48:28,404 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:48:28,404 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:48:29,371 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:48:30,371 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:48:30,405 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:48:34,279 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:48:34,280 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:48:34,280 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:48:34,280 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:48:34,372 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:48:35,694 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:48:36,373 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:48:39,133 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:48:40,558 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:48:40,558 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:48:40,558 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:48:40,559 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:48:41,374 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:48:41,559 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:48:42,375 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:48:43,118 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:48:43,119 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:48:46,462 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:48:46,463 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:48:46,463 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:48:46,463 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:48:47,376 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:48:47,464 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:48:48,376 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:48:52,337 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:48:52,338 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:48:52,338 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:48:52,338 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:48:52,377 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:48:53,339 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:48:54,378 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:48:58,118 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:48:58,119 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:48:58,219 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:48:58,329 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:48:58,329 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:48:58,329 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:48:58,379 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:48:59,330 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:49:00,379 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:49:04,099 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:49:04,100 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:49:04,100 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:49:04,100 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:49:04,380 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:49:05,100 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:49:06,381 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:49:09,134 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:49:09,981 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:49:09,982 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:49:09,982 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:49:09,982 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:49:10,382 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:49:10,983 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:49:12,383 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:49:13,118 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:49:13,119 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:49:15,871 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:49:15,871 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:49:15,872 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:49:15,872 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:49:16,384 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:49:16,872 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:49:18,384 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:49:21,767 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:49:21,767 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:49:21,768 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:49:21,768 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:49:22,385 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:49:22,385 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:49:22,768 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:49:27,769 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:49:32,152 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:49:32,153 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:49:33,325 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:49:37,698 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:49:37,698 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:49:37,699 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:49:37,699 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:49:38,389 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:49:38,389 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:49:38,699 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:49:39,134 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:49:43,516 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:49:43,516 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:49:43,517 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:49:43,517 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:49:44,391 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:49:44,391 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:49:44,517 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:49:47,152 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:49:47,153 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:49:49,422 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:49:49,422 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:49:49,423 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:49:49,423 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:49:50,392 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:49:50,392 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:49:50,424 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:49:55,255 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:49:55,256 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:49:55,256 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:49:55,256 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:49:55,393 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:49:56,257 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:49:56,394 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:50:01,151 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:50:01,152 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:50:01,152 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:50:01,152 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:50:01,395 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:50:02,153 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:50:02,153 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:50:02,153 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:50:02,395 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:50:07,078 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:50:07,078 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:50:07,079 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:50:07,079 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:50:07,397 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:50:08,079 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:50:08,397 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:50:09,135 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:50:12,925 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:50:12,925 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:50:12,926 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:50:12,926 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:50:13,398 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:50:13,926 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:50:14,399 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:50:17,152 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:50:17,153 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:50:18,866 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:50:18,866 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:50:18,867 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:50:18,867 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:50:19,400 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:50:19,867 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:50:20,400 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:50:24,758 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:50:24,759 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:50:24,759 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:50:24,759 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:50:25,402 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:50:25,760 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:50:26,402 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:50:30,664 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:50:30,665 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:50:30,665 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:50:30,666 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:50:31,403 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:50:31,666 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:50:32,153 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:50:32,153 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:50:32,403 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:50:36,606 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:50:36,606 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:50:36,607 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:50:36,607 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:50:37,405 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:50:37,607 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:50:38,405 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:50:39,135 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:50:42,462 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:50:42,463 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:50:42,463 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:50:42,463 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:50:43,407 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:50:43,464 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:50:44,407 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:50:47,153 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:50:47,153 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:50:48,406 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:50:48,406 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:50:48,407 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:50:48,407 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:50:48,408 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:50:49,407 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:50:50,409 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:50:54,266 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:50:54,267 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:50:54,267 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:50:54,267 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:50:54,410 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:50:55,268 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:50:56,410 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:51:00,193 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:51:00,199 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:51:00,199 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:51:00,200 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:51:00,412 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:51:01,200 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:51:02,153 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:51:02,153 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:51:02,413 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:51:06,142 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:51:06,142 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:51:06,143 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:51:06,143 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:51:06,414 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:51:07,143 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:51:08,414 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:51:09,136 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:51:11,992 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:51:11,992 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:51:11,993 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:51:11,993 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:51:12,415 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:51:12,993 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:51:14,416 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:51:17,153 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:51:17,154 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:51:17,938 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:51:17,938 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:51:17,939 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:51:17,939 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:51:18,417 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:51:18,417 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:51:18,939 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:51:23,813 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:51:23,814 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:51:23,814 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:51:23,815 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:51:24,418 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:51:24,419 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:51:24,815 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:51:29,716 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:51:29,716 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:51:29,717 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:51:29,717 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:51:30,420 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:51:30,420 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:51:30,717 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:51:32,153 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:51:32,154 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:51:35,632 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:51:35,632 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:51:35,633 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:51:35,633 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:51:36,421 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:51:36,421 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:51:36,633 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:51:39,136 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:51:41,545 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:51:41,545 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:51:41,546 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:51:41,546 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:51:42,423 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:51:42,423 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:51:42,546 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:51:47,153 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:51:47,154 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:51:47,478 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:51:47,478 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:51:47,479 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:51:47,479 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:51:48,424 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:51:48,424 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:51:48,479 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:51:53,354 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:51:53,354 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:51:53,355 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:51:53,355 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:51:53,425 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:51:54,355 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:51:54,425 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:51:59,259 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:51:59,259 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:51:59,260 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:51:59,260 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:51:59,426 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:52:00,260 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:52:00,427 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:52:02,154 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:52:02,154 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:52:05,206 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:52:05,207 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:52:05,207 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:52:05,207 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:52:05,428 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:52:06,207 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:52:06,428 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:52:09,137 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:52:11,070 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:52:11,071 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:52:11,071 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:52:11,071 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:52:11,429 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:52:12,071 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:52:12,430 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:52:16,974 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:52:16,975 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:52:16,975 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:52:16,975 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:52:17,154 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:52:17,154 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:52:17,154 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:52:17,431 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:52:18,431 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:52:22,334 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:52:22,914 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:52:22,914 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:52:22,915 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:52:22,915 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:52:23,432 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:52:24,432 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:52:27,916 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:52:28,802 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:52:28,803 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:52:28,803 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:52:28,803 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:52:29,434 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:52:30,434 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:52:32,154 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:52:32,154 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:52:33,357 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:52:34,750 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:52:34,750 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:52:34,751 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:52:34,751 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:52:35,435 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:52:36,436 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:52:38,752 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:52:39,137 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:52:40,614 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:52:40,615 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:52:40,615 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:52:40,615 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:52:41,437 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:52:42,437 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:52:44,616 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:52:46,517 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:52:46,518 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:52:46,518 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:52:46,518 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:52:47,154 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:52:47,155 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:52:47,438 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:52:48,438 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:52:50,320 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:52:52,470 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:52:52,470 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:52:52,471 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:52:52,471 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:52:53,440 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:52:54,440 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:52:55,471 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:52:58,325 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:52:58,325 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:52:58,325 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:52:58,326 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:52:58,441 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:53:00,441 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:53:01,326 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:53:02,154 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:53:02,155 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:53:04,278 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:53:04,279 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:53:04,279 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:53:04,279 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:53:04,442 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:53:06,443 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:53:07,280 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:53:09,138 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:53:10,150 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:53:10,151 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:53:10,151 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:53:10,151 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:53:10,444 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:53:12,444 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:53:13,152 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:53:16,043 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:53:16,044 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:53:16,044 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:53:16,044 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:53:16,445 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:53:16,445 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:53:17,154 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:53:17,155 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:53:18,306 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:53:21,986 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:53:21,987 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:53:21,987 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:53:21,987 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:53:22,447 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:53:22,447 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:53:23,987 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:53:27,859 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:53:27,860 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:53:27,860 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:53:27,861 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:53:28,448 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:53:28,448 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:53:29,862 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:53:32,155 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:53:32,155 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:53:33,810 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:53:33,810 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:53:33,811 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:53:33,811 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:53:34,450 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:53:34,450 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:53:35,811 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:53:39,138 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:53:39,669 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:53:39,670 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:53:39,670 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:53:39,670 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:53:40,451 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:53:40,452 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:53:41,670 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:53:45,577 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:53:45,578 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:53:45,578 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:53:45,578 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:53:46,453 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:53:46,453 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:53:47,155 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:53:47,155 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:53:47,155 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:53:51,526 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:53:51,526 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:53:51,527 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:53:51,527 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:53:52,455 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:53:52,455 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:53:52,527 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:53:57,387 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:53:57,388 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:53:57,388 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:53:57,388 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:53:57,456 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:53:58,389 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:53:58,456 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:54:02,155 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:54:02,155 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:54:03,350 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:54:03,350 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:54:03,351 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:54:03,351 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:54:03,457 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:54:04,351 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:54:04,458 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:54:09,143 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:54:09,208 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:54:09,209 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:54:09,209 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:54:09,209 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:54:09,459 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:54:10,209 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:54:10,459 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:54:15,101 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:54:15,102 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:54:15,102 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:54:15,102 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:54:15,461 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:54:16,103 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:54:16,461 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:54:17,155 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:54:17,155 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:54:21,046 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:54:21,046 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:54:21,047 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:54:21,047 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:54:21,462 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:54:22,047 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:54:22,463 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:54:26,911 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:54:26,911 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:54:26,912 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:54:26,912 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:54:27,464 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:54:27,912 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:54:28,464 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:54:32,155 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:54:32,155 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:54:32,854 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:54:32,855 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:54:32,855 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:54:32,855 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:54:33,466 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:54:33,855 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:54:34,466 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:54:38,717 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:54:38,718 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:54:38,718 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:54:38,718 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:54:39,139 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:54:39,140 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:54:39,467 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:54:40,468 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:54:44,140 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:54:44,619 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:54:44,619 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:54:44,620 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:54:44,620 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:54:45,469 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:54:46,469 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:54:47,155 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:54:47,156 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:54:49,381 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:54:50,566 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:54:50,566 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:54:50,567 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:54:50,567 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:54:51,471 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:54:52,471 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:54:54,568 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:54:56,426 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:54:56,426 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:54:56,427 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:54:56,427 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:54:56,472 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:54:58,472 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:55:00,427 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:55:02,155 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:55:02,156 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:55:02,382 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:55:02,382 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:55:02,383 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:55:02,383 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:55:02,473 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:55:04,474 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:55:06,384 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:55:08,240 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:55:08,241 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:55:08,241 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:55:08,241 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:55:08,475 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:55:08,475 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:55:09,140 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:55:12,140 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:55:14,149 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:55:14,150 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:55:14,150 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:55:14,150 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:55:14,477 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:55:14,477 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:55:17,151 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:55:17,155 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:55:17,155 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:55:20,082 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:55:20,083 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:55:20,083 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:55:20,083 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:55:20,478 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:55:20,478 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:55:23,084 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:55:25,941 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:55:25,941 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:55:25,941 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:55:25,942 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:55:26,480 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:55:26,480 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:55:28,942 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:55:31,845 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:55:31,846 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:55:31,846 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:55:31,847 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:55:32,156 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:55:32,156 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:55:32,481 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:55:32,481 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:55:34,383 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:55:37,747 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:55:37,747 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:55:37,747 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:55:37,748 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:55:38,483 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:55:38,483 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:55:39,140 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:55:40,141 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:55:43,665 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:55:43,666 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:55:43,666 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:55:43,666 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:55:44,484 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:55:44,484 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:55:45,667 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:55:47,156 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:55:47,156 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:55:49,614 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:55:49,615 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:55:49,615 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:55:49,615 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:55:50,486 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:55:50,486 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:55:51,615 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:55:55,478 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:55:55,479 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:55:55,479 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:55:55,479 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:55:55,487 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:55:56,487 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:55:57,480 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:56:01,381 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:56:01,382 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:56:01,382 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:56:01,382 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:56:01,488 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:56:02,156 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:56:02,156 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:56:02,489 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:56:03,289 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:56:07,334 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:56:07,334 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:56:07,335 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:56:07,335 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:56:07,490 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:56:08,335 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:56:08,490 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:56:09,141 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:56:13,193 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:56:13,194 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:56:13,194 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:56:13,194 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:56:13,491 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:56:14,194 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:56:14,492 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:56:17,156 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:56:17,156 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:56:19,162 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:56:19,162 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:56:19,163 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:56:19,163 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:56:19,493 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:56:20,163 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:56:20,493 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:56:25,025 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:56:25,026 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:56:25,026 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:56:25,026 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:56:25,495 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:56:26,027 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:56:26,495 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:56:30,940 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:56:30,940 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:56:30,940 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:56:30,940 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:56:31,496 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:56:31,941 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:56:32,156 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:56:32,156 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:56:32,496 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:56:36,890 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:56:36,890 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:56:36,891 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:56:36,891 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:56:37,498 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:56:37,891 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:56:38,498 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:56:39,141 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:56:42,746 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:56:42,747 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:56:42,747 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:56:42,747 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:56:43,499 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:56:43,747 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:56:44,500 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:56:47,156 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:56:47,156 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:56:48,686 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:56:48,686 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:56:48,687 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:56:48,687 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:56:49,501 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:56:49,687 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:56:50,501 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:56:54,548 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:56:54,548 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:56:54,548 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:56:54,549 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:56:55,502 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:56:55,549 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:56:56,503 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:57:00,448 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:57:00,449 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:57:00,449 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:57:00,449 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:57:00,504 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:57:01,449 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:57:02,156 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:57:02,157 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:57:02,504 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:57:06,406 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:57:06,406 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:57:06,407 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:57:06,407 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:57:06,505 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:57:06,505 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:57:07,407 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:57:09,142 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:57:12,272 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:57:12,276 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:57:12,276 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:57:12,276 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:57:12,507 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:57:12,507 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:57:13,276 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:57:17,156 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:57:17,157 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:57:18,226 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:57:18,226 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:57:18,227 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:57:18,227 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:57:18,508 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:57:18,509 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:57:19,227 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:57:24,089 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:57:24,090 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:57:24,090 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:57:24,090 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:57:24,510 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:57:24,510 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:57:25,090 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:57:29,989 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:57:29,989 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:57:29,990 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:57:29,990 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:57:30,512 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:57:30,512 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:57:30,990 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:57:32,156 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:57:32,157 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:57:35,930 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:57:35,931 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:57:35,931 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:57:35,932 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:57:36,513 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:57:36,513 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:57:36,932 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:57:39,142 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:57:41,801 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:57:41,802 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:57:41,802 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:57:41,802 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:57:42,515 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:57:42,515 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:57:42,803 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:57:47,156 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:57:47,157 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:57:47,750 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:57:47,750 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:57:47,751 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:57:47,751 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:57:48,516 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:57:48,517 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:57:48,751 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:57:53,626 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:57:53,627 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:57:53,627 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:57:53,627 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:57:54,518 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:57:54,627 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:57:55,518 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:57:59,603 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:57:59,604 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:57:59,604 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:57:59,604 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:58:00,520 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:58:00,604 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:58:01,520 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:58:02,156 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:58:02,157 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:58:05,558 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:58:05,558 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:58:05,559 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:58:05,559 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:58:06,521 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:58:06,559 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:58:07,522 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:58:09,143 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:58:11,411 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:58:11,412 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:58:11,412 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:58:11,412 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:58:11,523 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:58:12,412 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:58:13,523 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:58:17,157 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:58:17,157 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:58:17,326 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:58:17,327 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:58:17,327 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:58:17,327 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:58:17,524 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:58:18,328 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:58:19,525 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:58:23,228 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:58:23,228 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:58:23,229 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:58:23,229 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:58:23,526 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:58:24,229 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:58:25,527 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:58:29,123 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:58:29,123 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:58:29,124 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:58:29,124 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:58:29,528 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:58:30,124 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:58:31,528 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:58:32,157 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:58:32,157 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:58:35,082 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:58:35,082 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:58:35,083 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:58:35,083 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:58:35,336 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:58:35,529 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:58:37,530 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:58:39,143 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:58:41,144 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:58:41,231 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:58:41,231 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:58:41,232 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:58:41,232 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:58:41,531 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:58:43,532 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:58:46,232 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:58:47,125 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:58:47,126 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:58:47,126 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:58:47,126 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:58:47,169 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:58:47,169 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:58:47,533 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:58:49,533 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:58:51,390 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:58:53,031 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:58:53,032 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:58:53,032 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:58:53,032 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:58:53,535 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:58:55,535 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:58:57,033 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:58:58,927 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:58:58,928 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:58:58,928 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:58:58,928 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:58:59,536 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:59:01,537 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:59:02,157 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:59:02,157 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:59:02,158 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:59:04,886 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:59:04,886 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:59:04,887 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:59:04,887 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:59:05,538 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:59:07,538 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:59:07,887 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:59:09,144 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:59:10,749 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:59:10,749 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:59:10,749 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:59:10,750 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:59:11,540 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:59:13,540 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:59:13,750 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:59:16,650 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:59:16,651 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:59:16,651 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:59:16,651 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:59:17,157 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:59:17,157 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:59:17,541 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:59:19,352 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:59:19,542 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:59:22,545 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:59:22,546 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:59:22,546 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:59:22,546 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:59:23,543 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:59:23,543 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:59:24,547 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:59:28,447 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:59:28,447 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:59:28,448 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:59:28,448 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:59:28,544 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:59:29,545 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:59:30,448 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:59:32,157 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:59:32,158 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:59:34,410 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:59:34,410 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:59:34,411 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:59:34,411 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:59:34,546 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:59:35,546 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:59:36,411 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:59:39,144 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 19:59:40,275 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:59:40,276 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:59:40,276 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:59:40,276 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:59:40,548 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:59:41,548 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:59:42,276 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:59:46,172 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:59:46,172 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:59:46,172 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:59:46,173 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:59:46,549 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:59:47,158 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 19:59:47,158 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 19:59:47,358 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:59:47,549 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:59:52,110 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:59:52,110 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:59:52,111 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:59:52,111 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:59:52,551 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:59:53,111 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:59:53,551 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 19:59:57,965 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 19:59:57,965 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 19:59:57,965 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 19:59:57,966 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 19:59:58,552 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 19:59:58,966 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 19:59:59,552 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:00:02,158 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:00:02,158 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:00:03,914 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:00:03,914 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:00:03,915 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:00:03,915 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:00:04,554 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:00:04,915 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:00:05,554 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:00:09,145 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:00:09,782 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:00:09,783 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:00:09,783 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:00:09,783 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:00:10,555 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:00:10,784 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:00:11,556 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:00:15,678 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:00:15,682 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:00:15,682 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:00:15,682 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:00:16,557 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:00:16,683 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:00:17,158 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:00:17,158 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:00:17,557 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:00:21,630 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:00:21,630 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:00:21,631 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:00:21,631 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:00:22,559 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:00:22,631 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:00:23,559 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:00:27,495 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:00:27,496 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:00:27,496 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:00:27,496 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:00:27,560 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:00:28,497 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:00:29,561 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:00:32,158 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:00:32,158 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:00:33,442 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:00:33,442 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:00:33,443 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:00:33,443 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:00:33,562 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:00:34,443 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:00:35,562 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:00:39,145 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:00:39,305 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:00:39,305 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:00:39,306 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:00:39,306 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:00:39,563 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:00:40,306 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:00:41,564 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:00:45,205 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:00:45,205 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:00:45,205 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:00:45,206 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:00:45,565 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:00:46,206 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:00:47,158 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:00:47,158 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:00:47,566 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:00:51,154 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:00:51,154 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:00:51,155 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:00:51,155 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:00:51,567 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:00:52,155 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:00:53,567 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:00:57,023 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:00:57,023 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:00:57,024 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:00:57,024 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:00:57,569 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:00:58,024 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:00:59,569 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:01:02,158 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:01:02,158 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:01:02,974 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:01:02,974 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:01:02,975 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:01:02,975 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:01:03,570 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:01:03,975 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:01:05,571 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:01:08,843 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:01:08,844 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:01:08,844 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:01:08,844 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:01:09,146 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:01:09,147 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:01:09,572 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:01:11,573 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:01:14,147 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:01:14,745 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:01:14,745 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:01:14,745 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:01:14,746 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:01:15,574 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:01:17,158 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:01:17,158 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:01:17,574 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:01:19,373 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:01:20,706 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:01:20,706 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:01:20,707 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:01:20,707 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:01:21,576 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:01:21,576 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:01:24,707 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:01:26,564 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:01:26,565 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:01:26,565 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:01:26,565 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:01:26,577 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:01:27,577 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:01:30,566 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:01:35,566 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:01:39,146 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:01:39,455 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:01:39,455 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:01:40,619 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:01:44,994 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:01:44,994 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:01:44,995 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:01:44,995 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:01:45,581 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:01:45,995 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:01:47,582 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:01:50,807 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:01:50,808 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:01:50,808 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:01:50,808 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:01:51,583 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:01:51,809 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:01:53,584 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:01:54,454 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:01:54,455 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:01:56,673 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:01:56,674 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:01:56,674 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:01:56,674 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:01:57,585 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:01:57,585 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:01:57,675 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:02:02,533 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:02:02,533 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:02:02,533 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:02:02,534 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:02:02,586 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:02:03,534 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:02:03,586 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:02:08,406 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:02:08,406 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:02:08,407 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:02:08,407 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:02:08,588 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:02:09,147 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:02:09,147 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:02:09,454 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:02:09,455 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:02:09,588 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:02:14,300 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:02:14,301 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:02:14,301 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:02:14,301 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:02:14,301 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:02:14,589 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:02:15,589 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:02:19,302 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:02:20,194 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:02:20,194 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:02:20,195 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:02:20,195 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:02:20,591 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:02:21,591 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:02:24,454 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:02:24,455 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:02:24,665 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:02:26,092 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:02:26,093 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:02:26,093 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:02:26,093 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:02:26,592 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:02:27,593 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:02:30,094 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:02:31,994 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:02:31,995 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:02:31,995 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:02:31,995 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:02:32,594 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:02:33,594 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:02:35,996 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:02:37,893 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:02:37,894 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:02:37,894 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:02:37,894 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:02:38,596 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:02:39,147 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:02:39,455 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:02:39,455 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:02:39,596 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:02:41,612 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:02:43,802 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:02:43,803 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:02:43,803 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:02:43,804 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:02:44,597 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:02:45,598 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:02:46,804 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:02:49,704 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:02:49,705 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:02:49,705 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:02:49,706 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:02:50,599 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:02:51,599 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:02:52,706 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:02:54,455 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:02:54,455 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:02:55,603 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:02:55,604 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:02:55,604 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:02:55,604 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:02:56,600 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:02:57,601 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:02:58,605 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:03:01,507 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:03:01,508 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:03:01,508 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:03:01,508 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:03:01,602 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:03:03,602 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:03:04,509 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:03:07,414 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:03:07,415 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:03:07,415 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:03:07,415 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:03:07,603 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:03:09,148 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:03:09,455 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:03:09,455 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:03:09,603 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:03:09,628 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:03:13,324 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:03:13,324 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:03:13,325 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:03:13,325 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:03:13,605 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:03:15,325 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:03:15,605 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:03:19,230 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:03:19,230 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:03:19,230 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:03:19,231 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:03:19,607 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:03:21,231 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:03:21,607 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:03:24,455 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:03:24,455 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:03:25,136 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:03:25,136 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:03:25,137 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:03:25,137 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:03:25,608 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:03:27,137 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:03:27,609 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:03:31,034 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:03:31,034 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:03:31,035 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:03:31,035 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:03:31,610 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:03:33,035 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:03:33,610 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:03:36,924 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:03:36,928 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:03:36,928 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:03:36,929 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:03:37,611 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:03:38,929 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:03:39,148 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:03:39,455 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:03:39,455 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:03:39,612 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:03:42,848 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:03:42,848 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:03:42,848 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:03:42,849 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:03:43,613 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:03:43,613 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:03:44,849 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:03:48,746 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:03:48,747 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:03:48,747 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:03:48,747 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:03:49,615 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:03:49,615 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:03:50,748 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:03:54,455 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:03:54,456 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:03:54,653 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:03:54,671 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:03:54,671 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:03:54,671 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:03:55,616 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:03:55,616 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:03:56,672 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:04:00,602 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:04:00,602 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:04:00,603 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:04:00,603 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:04:00,617 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:04:01,618 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:04:02,603 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:04:06,467 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:04:06,468 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:04:06,468 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:04:06,469 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:04:06,619 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:04:07,619 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:04:08,469 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:04:09,149 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:04:09,455 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:04:09,456 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:04:12,374 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:04:12,375 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:04:12,375 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:04:12,376 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:04:12,621 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:04:13,621 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:04:14,376 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:04:18,267 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:04:18,268 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:04:18,268 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:04:18,268 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:04:18,622 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:04:19,623 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:04:20,269 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:04:24,165 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:04:24,166 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:04:24,166 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:04:24,167 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:04:24,455 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:04:24,456 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:04:24,624 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:04:25,619 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:04:25,624 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:04:30,075 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:04:30,075 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:04:30,076 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:04:30,076 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:04:30,625 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:04:31,076 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:04:31,626 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:04:35,974 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:04:35,975 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:04:35,975 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:04:35,975 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:04:36,627 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:04:36,976 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:04:37,627 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:04:39,149 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:04:39,456 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:04:39,456 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:04:41,870 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:04:41,870 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:04:41,871 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:04:41,871 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:04:42,629 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:04:42,871 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:04:43,629 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:04:47,775 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:04:47,775 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:04:47,776 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:04:47,776 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:04:48,630 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:04:48,776 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:04:49,631 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:04:53,686 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:04:53,686 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:04:53,686 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:04:53,687 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:04:54,456 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:04:54,456 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:04:54,632 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:04:54,665 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:04:55,632 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:04:59,588 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:04:59,589 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:04:59,589 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:04:59,589 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:04:59,634 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:05:00,590 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:05:01,634 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:05:05,493 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:05:05,493 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:05:05,494 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:05:05,494 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:05:05,635 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:05:06,494 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:05:07,636 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:05:09,150 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:05:09,456 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:05:09,456 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:05:11,395 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:05:11,396 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:05:11,396 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:05:11,396 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:05:11,637 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:05:12,396 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:05:13,637 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:05:17,307 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:05:17,308 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:05:17,308 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:05:17,308 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:05:17,638 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:05:18,309 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:05:19,639 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:05:23,219 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:05:23,220 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:05:23,220 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:05:23,220 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:05:23,640 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:05:24,220 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:05:24,456 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:05:24,456 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:05:25,640 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:05:29,134 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:05:29,135 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:05:29,135 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:05:29,135 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:05:29,642 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:05:30,136 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:05:31,642 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:05:35,041 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:05:35,042 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:05:35,042 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:05:35,042 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:05:35,643 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:05:36,043 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:05:37,644 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:05:39,150 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:05:39,456 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:05:39,457 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:05:40,955 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:05:40,956 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:05:40,956 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:05:40,956 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:05:41,645 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:05:41,645 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:05:41,957 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:05:46,853 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:05:46,853 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:05:46,854 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:05:46,854 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:05:47,647 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:05:47,647 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:05:47,854 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:05:52,753 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:05:52,754 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:05:52,754 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:05:52,754 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:05:53,649 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:05:53,649 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:05:53,755 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:05:54,456 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:05:54,457 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:05:58,661 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:05:58,661 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:05:58,662 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:05:58,662 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:05:59,650 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:05:59,651 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:05:59,662 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:06:04,569 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:06:04,570 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:06:04,570 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:06:04,570 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:06:04,652 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:06:05,571 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:06:05,652 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:06:09,151 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:06:09,456 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:06:09,457 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:06:10,481 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:06:10,482 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:06:10,482 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:06:10,482 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:06:10,653 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:06:11,482 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:06:11,654 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:06:16,388 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:06:16,388 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:06:16,389 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:06:16,389 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:06:16,655 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:06:17,389 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:06:17,656 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:06:22,309 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:06:22,309 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:06:22,309 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:06:22,310 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:06:22,657 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:06:23,310 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:06:23,657 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:06:24,456 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:06:24,457 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:06:28,218 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:06:28,219 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:06:28,219 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:06:28,219 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:06:28,659 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:06:29,220 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:06:29,659 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:06:34,125 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:06:34,125 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:06:34,125 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:06:34,126 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:06:34,660 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:06:35,126 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:06:35,660 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:06:39,151 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:06:39,456 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:06:39,457 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:06:40,026 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:06:40,030 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:06:40,031 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:06:40,031 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:06:40,662 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:06:41,031 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:06:41,662 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:06:45,933 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:06:45,933 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:06:45,933 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:06:45,934 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:06:46,664 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:06:46,934 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:06:47,664 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:06:51,842 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:06:51,842 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:06:51,842 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:06:51,843 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:06:52,665 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:06:52,843 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:06:53,666 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:06:54,457 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:06:54,457 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:06:57,748 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:06:57,748 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:06:57,749 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:06:57,749 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:06:58,667 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:06:58,749 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:06:59,667 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:07:03,648 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:07:03,649 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:07:03,649 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:07:03,650 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:07:03,668 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:07:04,650 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:07:05,669 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:07:09,152 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:07:09,457 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:07:09,457 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:07:09,571 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:07:09,636 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:07:09,636 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:07:09,637 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:07:09,670 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:07:10,637 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:07:11,671 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:07:15,459 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:07:15,459 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:07:15,459 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:07:15,460 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:07:15,672 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:07:16,460 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:07:17,672 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:07:21,361 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:07:21,362 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:07:21,362 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:07:21,362 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:07:21,673 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:07:22,363 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:07:23,674 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:07:24,457 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:07:24,457 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:07:27,270 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:07:27,270 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:07:27,271 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:07:27,271 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:07:27,675 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:07:28,271 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:07:29,675 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:07:33,177 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:07:33,178 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:07:33,178 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:07:33,178 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:07:33,676 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:07:34,178 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:07:35,677 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:07:39,085 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:07:39,086 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:07:39,086 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:07:39,087 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:07:39,152 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:07:39,458 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:07:39,459 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:07:39,650 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:07:39,678 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:07:39,678 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:07:44,650 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:07:44,985 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:07:44,985 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:07:44,986 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:07:44,986 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:07:45,679 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:07:45,679 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:07:49,987 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:07:50,895 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:07:50,895 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:07:50,896 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:07:50,896 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:07:51,681 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:07:51,681 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:07:54,458 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:07:54,459 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:07:55,625 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:07:56,797 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:07:56,797 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:07:56,798 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:07:56,798 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:07:57,682 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:07:57,683 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:08:00,799 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:08:02,704 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:08:02,704 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:08:02,704 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:08:02,705 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:08:03,684 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:08:03,684 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:08:06,705 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:08:08,625 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:08:08,625 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:08:08,626 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:08:08,626 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:08:08,685 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:08:09,153 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:08:09,458 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:08:09,459 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:08:09,686 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:08:12,695 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:08:14,531 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:08:14,532 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:08:14,532 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:08:14,532 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:08:14,688 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:08:15,687 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:08:18,533 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:08:20,451 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:08:20,452 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:08:20,452 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:08:20,452 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:08:20,689 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:08:21,689 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:08:24,453 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:08:24,458 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:08:24,459 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:08:26,361 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:08:26,362 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:08:26,362 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:08:26,362 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:08:26,690 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:08:27,691 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:08:30,363 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:08:32,298 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:08:32,299 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:08:32,299 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:08:32,299 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:08:32,692 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:08:33,692 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:08:36,300 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:08:38,196 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:08:38,196 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:08:38,197 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:08:38,197 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:08:38,615 DEBUG SenderThread:27237 [sender.py:send():378] send: telemetry +2024-05-25 20:08:38,615 DEBUG SenderThread:27237 [sender.py:send():378] send: exit +2024-05-25 20:08:38,615 INFO SenderThread:27237 [sender.py:send_exit():585] handling exit code: 0 +2024-05-25 20:08:38,615 INFO SenderThread:27237 [sender.py:send_exit():587] handling runtime: 2519 +2024-05-25 20:08:38,616 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:08:38,616 INFO SenderThread:27237 [sender.py:send_exit():593] send defer +2024-05-25 20:08:38,616 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: defer +2024-05-25 20:08:38,616 INFO HandlerThread:27237 [handler.py:handle_request_defer():184] handle defer: 0 +2024-05-25 20:08:38,616 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: defer +2024-05-25 20:08:38,616 INFO SenderThread:27237 [sender.py:send_request_defer():609] handle sender defer: 0 +2024-05-25 20:08:38,616 INFO SenderThread:27237 [sender.py:transition_state():613] send defer: 1 +2024-05-25 20:08:38,616 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: defer +2024-05-25 20:08:38,616 INFO HandlerThread:27237 [handler.py:handle_request_defer():184] handle defer: 1 +2024-05-25 20:08:38,616 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: defer +2024-05-25 20:08:38,616 INFO SenderThread:27237 [sender.py:send_request_defer():609] handle sender defer: 1 +2024-05-25 20:08:38,616 INFO SenderThread:27237 [sender.py:transition_state():613] send defer: 2 +2024-05-25 20:08:38,616 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: defer +2024-05-25 20:08:38,616 INFO HandlerThread:27237 [handler.py:handle_request_defer():184] handle defer: 2 +2024-05-25 20:08:38,616 INFO HandlerThread:27237 [system_monitor.py:finish():203] Stopping system monitor +2024-05-25 20:08:38,617 INFO HandlerThread:27237 [interfaces.py:finish():200] Joined cpu monitor +2024-05-25 20:08:38,617 DEBUG SystemMonitor:27237 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-05-25 20:08:38,617 DEBUG SystemMonitor:27237 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-05-25 20:08:38,618 INFO HandlerThread:27237 [interfaces.py:finish():200] Joined disk monitor +2024-05-25 20:08:38,641 INFO HandlerThread:27237 [interfaces.py:finish():200] Joined gpu monitor +2024-05-25 20:08:38,642 INFO HandlerThread:27237 [interfaces.py:finish():200] Joined memory monitor +2024-05-25 20:08:38,642 INFO HandlerThread:27237 [interfaces.py:finish():200] Joined network monitor +2024-05-25 20:08:38,642 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: defer +2024-05-25 20:08:38,642 INFO SenderThread:27237 [sender.py:send_request_defer():609] handle sender defer: 2 +2024-05-25 20:08:38,642 INFO SenderThread:27237 [sender.py:transition_state():613] send defer: 3 +2024-05-25 20:08:38,642 DEBUG SenderThread:27237 [sender.py:send():378] send: stats +2024-05-25 20:08:38,642 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: defer +2024-05-25 20:08:38,642 INFO HandlerThread:27237 [handler.py:handle_request_defer():184] handle defer: 3 +2024-05-25 20:08:38,643 DEBUG SenderThread:27237 [sender.py:send():378] send: history +2024-05-25 20:08:38,643 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:08:38,643 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:08:38,643 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: defer +2024-05-25 20:08:38,643 INFO SenderThread:27237 [sender.py:send_request_defer():609] handle sender defer: 3 +2024-05-25 20:08:38,643 INFO SenderThread:27237 [sender.py:transition_state():613] send defer: 4 +2024-05-25 20:08:38,643 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: defer +2024-05-25 20:08:38,643 INFO HandlerThread:27237 [handler.py:handle_request_defer():184] handle defer: 4 +2024-05-25 20:08:38,643 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: defer +2024-05-25 20:08:38,644 INFO SenderThread:27237 [sender.py:send_request_defer():609] handle sender defer: 4 +2024-05-25 20:08:38,644 INFO SenderThread:27237 [sender.py:transition_state():613] send defer: 5 +2024-05-25 20:08:38,644 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: defer +2024-05-25 20:08:38,644 INFO HandlerThread:27237 [handler.py:handle_request_defer():184] handle defer: 5 +2024-05-25 20:08:38,644 DEBUG SenderThread:27237 [sender.py:send():378] send: summary +2024-05-25 20:08:38,644 INFO SenderThread:27237 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:08:38,644 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: defer +2024-05-25 20:08:38,644 INFO SenderThread:27237 [sender.py:send_request_defer():609] handle sender defer: 5 +2024-05-25 20:08:38,644 INFO SenderThread:27237 [sender.py:transition_state():613] send defer: 6 +2024-05-25 20:08:38,644 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: defer +2024-05-25 20:08:38,644 INFO HandlerThread:27237 [handler.py:handle_request_defer():184] handle defer: 6 +2024-05-25 20:08:38,644 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: defer +2024-05-25 20:08:38,644 INFO SenderThread:27237 [sender.py:send_request_defer():609] handle sender defer: 6 +2024-05-25 20:08:38,646 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:08:38,694 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:08:38,798 INFO SenderThread:27237 [sender.py:transition_state():613] send defer: 7 +2024-05-25 20:08:38,798 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: defer +2024-05-25 20:08:38,798 INFO HandlerThread:27237 [handler.py:handle_request_defer():184] handle defer: 7 +2024-05-25 20:08:38,798 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: defer +2024-05-25 20:08:38,798 INFO SenderThread:27237 [sender.py:send_request_defer():609] handle sender defer: 7 +2024-05-25 20:08:39,322 INFO SenderThread:27237 [sender.py:transition_state():613] send defer: 8 +2024-05-25 20:08:39,322 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: defer +2024-05-25 20:08:39,322 INFO HandlerThread:27237 [handler.py:handle_request_defer():184] handle defer: 8 +2024-05-25 20:08:39,322 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: defer +2024-05-25 20:08:39,322 INFO SenderThread:27237 [sender.py:send_request_defer():609] handle sender defer: 8 +2024-05-25 20:08:39,322 INFO SenderThread:27237 [job_builder.py:build():432] Attempting to build job artifact +2024-05-25 20:08:39,323 INFO SenderThread:27237 [job_builder.py:_get_source_type():565] is repo sourced job +2024-05-25 20:08:39,323 WARNING SenderThread:27237 [job_builder.py:_log_if_verbose():267] No program path found, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job +2024-05-25 20:08:39,323 INFO SenderThread:27237 [sender.py:transition_state():613] send defer: 9 +2024-05-25 20:08:39,323 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: defer +2024-05-25 20:08:39,323 INFO HandlerThread:27237 [handler.py:handle_request_defer():184] handle defer: 9 +2024-05-25 20:08:39,323 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: defer +2024-05-25 20:08:39,323 INFO SenderThread:27237 [sender.py:send_request_defer():609] handle sender defer: 9 +2024-05-25 20:08:39,323 INFO SenderThread:27237 [dir_watcher.py:finish():358] shutting down directory watcher +2024-05-25 20:08:39,616 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: poll_exit +2024-05-25 20:08:39,694 INFO Thread-12 :27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:08:39,694 INFO SenderThread:27237 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/config.yaml +2024-05-25 20:08:39,695 INFO SenderThread:27237 [dir_watcher.py:finish():388] scan: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files +2024-05-25 20:08:39,695 INFO SenderThread:27237 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/conda-environment.yaml conda-environment.yaml +2024-05-25 20:08:39,695 INFO SenderThread:27237 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log output.log +2024-05-25 20:08:39,695 INFO SenderThread:27237 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-metadata.json wandb-metadata.json +2024-05-25 20:08:39,695 INFO SenderThread:27237 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/config.yaml config.yaml +2024-05-25 20:08:39,695 INFO SenderThread:27237 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/requirements.txt requirements.txt +2024-05-25 20:08:39,695 INFO SenderThread:27237 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json wandb-summary.json +2024-05-25 20:08:39,699 INFO SenderThread:27237 [sender.py:transition_state():613] send defer: 10 +2024-05-25 20:08:39,699 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: poll_exit +2024-05-25 20:08:39,700 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: defer +2024-05-25 20:08:39,700 INFO HandlerThread:27237 [handler.py:handle_request_defer():184] handle defer: 10 +2024-05-25 20:08:39,701 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: defer +2024-05-25 20:08:39,701 INFO SenderThread:27237 [sender.py:send_request_defer():609] handle sender defer: 10 +2024-05-25 20:08:39,701 INFO SenderThread:27237 [file_pusher.py:finish():169] shutting down file pusher +2024-05-25 20:08:40,051 INFO wandb-upload_1:27237 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/conda-environment.yaml +2024-05-25 20:08:40,069 INFO wandb-upload_4:27237 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/wandb-summary.json +2024-05-25 20:08:40,077 INFO wandb-upload_3:27237 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/requirements.txt +2024-05-25 20:08:40,085 INFO wandb-upload_2:27237 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/config.yaml +2024-05-25 20:08:40,258 INFO wandb-upload_0:27237 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/files/output.log +2024-05-25 20:08:40,459 INFO Thread-11 (_thread_body):27237 [sender.py:transition_state():613] send defer: 11 +2024-05-25 20:08:40,459 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: defer +2024-05-25 20:08:40,459 INFO HandlerThread:27237 [handler.py:handle_request_defer():184] handle defer: 11 +2024-05-25 20:08:40,460 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: defer +2024-05-25 20:08:40,460 INFO SenderThread:27237 [sender.py:send_request_defer():609] handle sender defer: 11 +2024-05-25 20:08:40,460 INFO SenderThread:27237 [file_pusher.py:join():175] waiting for file pusher +2024-05-25 20:08:40,460 INFO SenderThread:27237 [sender.py:transition_state():613] send defer: 12 +2024-05-25 20:08:40,460 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: defer +2024-05-25 20:08:40,460 INFO HandlerThread:27237 [handler.py:handle_request_defer():184] handle defer: 12 +2024-05-25 20:08:40,460 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: defer +2024-05-25 20:08:40,460 INFO SenderThread:27237 [sender.py:send_request_defer():609] handle sender defer: 12 +2024-05-25 20:08:40,460 INFO SenderThread:27237 [file_stream.py:finish():601] file stream finish called +2024-05-25 20:08:40,602 INFO SenderThread:27237 [file_stream.py:finish():605] file stream finish is done +2024-05-25 20:08:40,602 INFO SenderThread:27237 [sender.py:transition_state():613] send defer: 13 +2024-05-25 20:08:40,602 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: defer +2024-05-25 20:08:40,602 INFO HandlerThread:27237 [handler.py:handle_request_defer():184] handle defer: 13 +2024-05-25 20:08:40,602 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: defer +2024-05-25 20:08:40,602 INFO SenderThread:27237 [sender.py:send_request_defer():609] handle sender defer: 13 +2024-05-25 20:08:40,602 INFO SenderThread:27237 [sender.py:transition_state():613] send defer: 14 +2024-05-25 20:08:40,602 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: defer +2024-05-25 20:08:40,602 INFO HandlerThread:27237 [handler.py:handle_request_defer():184] handle defer: 14 +2024-05-25 20:08:40,603 DEBUG SenderThread:27237 [sender.py:send():378] send: final +2024-05-25 20:08:40,603 DEBUG SenderThread:27237 [sender.py:send():378] send: footer +2024-05-25 20:08:40,603 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: defer +2024-05-25 20:08:40,603 INFO SenderThread:27237 [sender.py:send_request_defer():609] handle sender defer: 14 +2024-05-25 20:08:40,603 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: poll_exit +2024-05-25 20:08:40,604 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: poll_exit +2024-05-25 20:08:40,604 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: internal_messages +2024-05-25 20:08:40,604 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: server_info +2024-05-25 20:08:40,604 DEBUG SenderThread:27237 [sender.py:send_request():405] send_request: server_info +2024-05-25 20:08:40,646 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: get_summary +2024-05-25 20:08:40,646 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: sampled_history +2024-05-25 20:08:40,736 DEBUG HandlerThread:27237 [handler.py:handle_request():158] handle_request: shutdown +2024-05-25 20:08:40,736 INFO HandlerThread:27237 [handler.py:finish():882] shutting down handler +2024-05-25 20:08:41,604 INFO WriterThread:27237 [datastore.py:close():296] close: /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/run-zf4t8z6a.wandb +2024-05-25 20:08:41,736 INFO SenderThread:27237 [sender.py:finish():1545] shutting down sender +2024-05-25 20:08:41,736 INFO SenderThread:27237 [file_pusher.py:finish():169] shutting down file pusher +2024-05-25 20:08:41,736 INFO SenderThread:27237 [file_pusher.py:join():175] waiting for file pusher diff --git a/runs/wandb/run-20240525_192638-zf4t8z6a/logs/debug.log b/runs/wandb/run-20240525_192638-zf4t8z6a/logs/debug.log new file mode 100644 index 0000000000000000000000000000000000000000..d7b276dac5a099f67f90e18de8ac7eef270b86ba --- /dev/null +++ b/runs/wandb/run-20240525_192638-zf4t8z6a/logs/debug.log @@ -0,0 +1,36 @@ +2024-05-25 19:26:38,715 INFO MainThread:27183 [wandb_setup.py:_flush():76] Current SDK version is 0.17.0 +2024-05-25 19:26:38,715 INFO MainThread:27183 [wandb_setup.py:_flush():76] Configure stats pid to 27183 +2024-05-25 19:26:38,715 INFO MainThread:27183 [wandb_setup.py:_flush():76] Loading settings from /root/.config/wandb/settings +2024-05-25 19:26:38,715 INFO MainThread:27183 [wandb_setup.py:_flush():76] Loading settings from /root/mistral-finetune/wandb/settings +2024-05-25 19:26:38,716 INFO MainThread:27183 [wandb_setup.py:_flush():76] Loading settings from environment variables: {} +2024-05-25 19:26:38,716 WARNING MainThread:27183 [wandb_setup.py:_flush():76] Could not find program at -m train +2024-05-25 19:26:38,716 INFO MainThread:27183 [wandb_setup.py:_flush():76] Inferring run settings from compute environment: {'program_relpath': None, 'program': '-m train'} +2024-05-25 19:26:38,716 INFO MainThread:27183 [wandb_setup.py:_flush():76] Applying login settings: {'api_key': '***REDACTED***'} +2024-05-25 19:26:38,716 INFO MainThread:27183 [wandb_setup.py:_flush():76] Applying login settings: {'api_key': '***REDACTED***'} +2024-05-25 19:26:38,716 INFO MainThread:27183 [wandb_setup.py:_flush():76] Applying login settings: {} +2024-05-25 19:26:38,716 INFO MainThread:27183 [wandb_init.py:_log_setup():520] Logging user logs to /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/logs/debug.log +2024-05-25 19:26:38,716 INFO MainThread:27183 [wandb_init.py:_log_setup():521] Logging internal logs to /root/mistral-finetune/runs/wandb/run-20240525_192638-zf4t8z6a/logs/debug-internal.log +2024-05-25 19:26:38,716 INFO MainThread:27183 [wandb_init.py:init():560] calling init triggers +2024-05-25 19:26:38,716 INFO MainThread:27183 [wandb_init.py:init():567] wandb.init called with sweep_config: {} +config: {'data': {'data': '', 'shuffle': False, 'instruct_data': '/root/data/mol_instructions_train.jsonl', 'eval_instruct_data': '', 'instruct': {'shuffle': True, 'dynamic_chunk_fn_call': True}}, 'model_id_or_path': '/root/mistral_models/7B-v0.3', 'run_dir': '/root/mistral-finetune/runs', 'optim': {'lr': 6e-05, 'weight_decay': 0.1, 'pct_start': 0.05}, 'seed': 0, 'num_microbatches': 1, 'seq_len': 32768, 'batch_size': 1, 'max_norm': 1.0, 'max_steps': 300, 'log_freq': 1, 'ckpt_freq': 100, 'ckpt_only_lora': True, 'no_ckpt': False, 'num_ckpt_keep': 3, 'eval_freq': 100, 'no_eval': True, 'checkpoint': True, 'world_size': 1, 'wandb': {'project': 'CHEMISTral7b-ft', 'offline': False, 'key': 'aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df', 'run_name': 'run0'}, 'mlflow': {'tracking_uri': None, 'experiment_name': None}, 'lora': {'enable': True, 'rank': 64, 'dropout': 0.0, 'scaling': 2.0}} +2024-05-25 19:26:38,716 INFO MainThread:27183 [wandb_init.py:init():610] starting backend +2024-05-25 19:26:38,716 INFO MainThread:27183 [wandb_init.py:init():614] setting up manager +2024-05-25 19:26:38,716 INFO MainThread:27183 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn +2024-05-25 19:26:38,717 INFO MainThread:27183 [wandb_init.py:init():622] backend started and connected +2024-05-25 19:26:38,718 INFO MainThread:27183 [wandb_init.py:init():711] updated telemetry +2024-05-25 19:26:38,720 INFO MainThread:27183 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout +2024-05-25 19:26:39,028 INFO MainThread:27183 [wandb_run.py:_on_init():2396] communicating current version +2024-05-25 19:26:39,057 INFO MainThread:27183 [wandb_run.py:_on_init():2405] got version response +2024-05-25 19:26:39,058 INFO MainThread:27183 [wandb_init.py:init():795] starting run threads in backend +2024-05-25 19:26:40,070 INFO MainThread:27183 [wandb_run.py:_console_start():2374] atexit reg +2024-05-25 19:26:40,070 INFO MainThread:27183 [wandb_run.py:_redirect():2229] redirect: wrap_raw +2024-05-25 19:26:40,070 INFO MainThread:27183 [wandb_run.py:_redirect():2294] Wrapping output streams. +2024-05-25 19:26:40,070 INFO MainThread:27183 [wandb_run.py:_redirect():2319] Redirects installed. +2024-05-25 19:26:40,071 INFO MainThread:27183 [wandb_init.py:init():838] run started, returning control to user process +2024-05-25 20:08:38,614 INFO MainThread:27183 [wandb_run.py:_finish():2103] finishing run artsy/CHEMISTral7b-ft/zf4t8z6a +2024-05-25 20:08:38,615 INFO MainThread:27183 [wandb_run.py:_atexit_cleanup():2343] got exitcode: 0 +2024-05-25 20:08:38,615 INFO MainThread:27183 [wandb_run.py:_restore():2326] restore +2024-05-25 20:08:38,615 INFO MainThread:27183 [wandb_run.py:_restore():2332] restore done +2024-05-25 20:08:41,738 INFO MainThread:27183 [wandb_run.py:_footer_history_summary_info():3994] rendering history +2024-05-25 20:08:41,738 INFO MainThread:27183 [wandb_run.py:_footer_history_summary_info():4026] rendering summary +2024-05-25 20:08:41,741 INFO MainThread:27183 [wandb_run.py:_footer_sync_info():3953] logging synced files diff --git a/runs/wandb/run-20240525_192638-zf4t8z6a/run-zf4t8z6a.wandb b/runs/wandb/run-20240525_192638-zf4t8z6a/run-zf4t8z6a.wandb new file mode 100644 index 0000000000000000000000000000000000000000..ca64022a47af841af0b3e8dd6d9bb219d491ba10 Binary files /dev/null and b/runs/wandb/run-20240525_192638-zf4t8z6a/run-zf4t8z6a.wandb differ diff --git a/runs2/args.yaml b/runs2/args.yaml new file mode 100644 index 0000000000000000000000000000000000000000..23dad6fbc1101eb41a4ad96da7252f29da93bc60 --- /dev/null +++ b/runs2/args.yaml @@ -0,0 +1,42 @@ +batch_size: 1 +checkpoint: true +ckpt_freq: 100 +ckpt_only_lora: false +data: + data: '' + eval_instruct_data: '' + instruct: + dynamic_chunk_fn_call: true + shuffle: true + instruct_data: /root/data/mol_instructions_train.jsonl + shuffle: false +eval_freq: 100 +log_freq: 1 +lora: + dropout: 0.0 + enable: true + rank: 64 + scaling: 2.0 +max_norm: 1.0 +max_steps: 500 +mlflow: + experiment_name: null + tracking_uri: null +model_id_or_path: /root/mistral_models/7B-v0.3 +no_ckpt: false +no_eval: true +num_ckpt_keep: 3 +num_microbatches: 1 +optim: + lr: 6.0e-05 + pct_start: 0.05 + weight_decay: 0.1 +run_dir: /root/mistral-finetune/runs2 +seed: 0 +seq_len: 32768 +wandb: + key: aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df + offline: false + project: CHEMISTral7b-ft + run_name: run1 +world_size: 1 diff --git a/runs2/checkpoints/checkpoint_000300/consolidated/consolidated.safetensors b/runs2/checkpoints/checkpoint_000300/consolidated/consolidated.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..f82172ee3f44bd216f26d66502eba71caf6d1ad3 --- /dev/null +++ b/runs2/checkpoints/checkpoint_000300/consolidated/consolidated.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:493c281359d5f07800e830ee3eaf0c546ce82092e7c384cbd4448092fe83cff3 +size 14496078512 diff --git a/runs2/checkpoints/checkpoint_000300/consolidated/params.json b/runs2/checkpoints/checkpoint_000300/consolidated/params.json new file mode 100644 index 0000000000000000000000000000000000000000..f6f914db94794fe23c78add929abbca1c57efa3c --- /dev/null +++ b/runs2/checkpoints/checkpoint_000300/consolidated/params.json @@ -0,0 +1,18 @@ +{ + "dim": 4096, + "n_layers": 32, + "head_dim": 128, + "hidden_dim": 14336, + "n_heads": 32, + "n_kv_heads": 8, + "norm_eps": 1e-05, + "vocab_size": 32768, + "rope_theta": 1000000.0, + "lora": { + "enable": true, + "rank": 64, + "dropout": 0.0, + "scaling": 2.0 + }, + "moe": null +} \ No newline at end of file diff --git a/runs2/checkpoints/checkpoint_000300/consolidated/tokenizer.model.v3 b/runs2/checkpoints/checkpoint_000300/consolidated/tokenizer.model.v3 new file mode 100644 index 0000000000000000000000000000000000000000..d8233e5b061987d32b63dbfb38fe86d7d4fc8a18 Binary files /dev/null and b/runs2/checkpoints/checkpoint_000300/consolidated/tokenizer.model.v3 differ diff --git a/runs2/checkpoints/checkpoint_000400/consolidated/consolidated.safetensors b/runs2/checkpoints/checkpoint_000400/consolidated/consolidated.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..c4790f76af66793ac097602064b0923b96f74081 --- /dev/null +++ b/runs2/checkpoints/checkpoint_000400/consolidated/consolidated.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b4f3c3b2096215b58b2d3c234a9e71c5efdca71e03f6eb975dc0ca1baf42b026 +size 14496078512 diff --git a/runs2/checkpoints/checkpoint_000400/consolidated/params.json b/runs2/checkpoints/checkpoint_000400/consolidated/params.json new file mode 100644 index 0000000000000000000000000000000000000000..f6f914db94794fe23c78add929abbca1c57efa3c --- /dev/null +++ b/runs2/checkpoints/checkpoint_000400/consolidated/params.json @@ -0,0 +1,18 @@ +{ + "dim": 4096, + "n_layers": 32, + "head_dim": 128, + "hidden_dim": 14336, + "n_heads": 32, + "n_kv_heads": 8, + "norm_eps": 1e-05, + "vocab_size": 32768, + "rope_theta": 1000000.0, + "lora": { + "enable": true, + "rank": 64, + "dropout": 0.0, + "scaling": 2.0 + }, + "moe": null +} \ No newline at end of file diff --git a/runs2/checkpoints/checkpoint_000400/consolidated/tokenizer.model.v3 b/runs2/checkpoints/checkpoint_000400/consolidated/tokenizer.model.v3 new file mode 100644 index 0000000000000000000000000000000000000000..d8233e5b061987d32b63dbfb38fe86d7d4fc8a18 Binary files /dev/null and b/runs2/checkpoints/checkpoint_000400/consolidated/tokenizer.model.v3 differ diff --git a/runs2/checkpoints/checkpoint_000500/consolidated/consolidated.safetensors b/runs2/checkpoints/checkpoint_000500/consolidated/consolidated.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..7c99c6e8a6161f2e9e59a771fbb69316742e8e24 --- /dev/null +++ b/runs2/checkpoints/checkpoint_000500/consolidated/consolidated.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7c46dde1479ea31d77d01adf3d41b4d3749006933927de1af653525df180614c +size 14496078512 diff --git a/runs2/checkpoints/checkpoint_000500/consolidated/params.json b/runs2/checkpoints/checkpoint_000500/consolidated/params.json new file mode 100644 index 0000000000000000000000000000000000000000..f6f914db94794fe23c78add929abbca1c57efa3c --- /dev/null +++ b/runs2/checkpoints/checkpoint_000500/consolidated/params.json @@ -0,0 +1,18 @@ +{ + "dim": 4096, + "n_layers": 32, + "head_dim": 128, + "hidden_dim": 14336, + "n_heads": 32, + "n_kv_heads": 8, + "norm_eps": 1e-05, + "vocab_size": 32768, + "rope_theta": 1000000.0, + "lora": { + "enable": true, + "rank": 64, + "dropout": 0.0, + "scaling": 2.0 + }, + "moe": null +} \ No newline at end of file diff --git a/runs2/checkpoints/checkpoint_000500/consolidated/tokenizer.model.v3 b/runs2/checkpoints/checkpoint_000500/consolidated/tokenizer.model.v3 new file mode 100644 index 0000000000000000000000000000000000000000..d8233e5b061987d32b63dbfb38fe86d7d4fc8a18 Binary files /dev/null and b/runs2/checkpoints/checkpoint_000500/consolidated/tokenizer.model.v3 differ diff --git a/runs2/metrics.train.jsonl b/runs2/metrics.train.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..213d66aa7bf7a5e40d28fab4e3393e63edba1cdf --- /dev/null +++ b/runs2/metrics.train.jsonl @@ -0,0 +1,500 @@ +{"lr": 2.3999999999999974e-06, "step": 1, "loss": 2.0530354976654053, "percent_done": 0.2, "peak_allocated_mem": 39.05608654022217, "allocated_mem": 20.13855266571045, "wps": 44.535382388698245, "avg_wps": 44.535382388698245, "eta_in_seconds": 367151.4899611473, "at": "2024-05-25T20:38:33.049408"} +{"lr": 2.646387992434257e-06, "step": 2, "loss": 2.2603445053100586, "percent_done": 0.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460636138916, "wps": 5696.623691536421, "avg_wps": 88.37982406003658, "eta_in_seconds": 184640.15032339096, "at": "2024-05-25T20:38:38.802880"} +{"lr": 3.3813362028748325e-06, "step": 3, "loss": 2.2443745136260986, "percent_done": 0.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460636138916, "wps": 5655.083661106985, "avg_wps": 131.54184281550238, "eta_in_seconds": 123806.20228075981, "at": "2024-05-25T20:38:44.598517"} +{"lr": 4.592269463674938e-06, "step": 4, "loss": 2.141585350036621, "percent_done": 0.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138083934783936, "wps": 5638.701375194719, "avg_wps": 174.03579857402448, "eta_in_seconds": 93388.41855049133, "at": "2024-05-25T20:38:50.411010"} +{"lr": 6.258468371008163e-06, "step": 5, "loss": 2.0383615493774414, "percent_done": 1.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137423038482666, "wps": 5630.194947066383, "avg_wps": 215.8765005141398, "eta_in_seconds": 75136.29302573204, "at": "2024-05-25T20:38:56.232286"} +{"lr": 8.351423799612423e-06, "step": 6, "loss": 2.3010313510894775, "percent_done": 1.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137425899505615, "wps": 5614.059759637658, "avg_wps": 257.07475014695797, "eta_in_seconds": 62967.646533727646, "at": "2024-05-25T20:39:02.070262"} +{"lr": 1.0835324701827431e-05, "step": 7, "loss": 2.6319689750671387, "percent_done": 1.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.139925479888916, "wps": 5602.815316772235, "avg_wps": 297.64439865264876, "eta_in_seconds": 54274.91353147371, "at": "2024-05-25T20:39:07.919924"} +{"lr": 1.3667670844548846e-05, "step": 8, "loss": 1.8229396343231201, "percent_done": 1.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460636138916, "wps": 5600.055050459757, "avg_wps": 337.60165322410666, "eta_in_seconds": 47754.07894492149, "at": "2024-05-25T20:39:13.772505"} +{"lr": 1.6799999999999995e-05, "step": 9, "loss": 2.1314971446990967, "percent_done": 1.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138203144073486, "wps": 5586.494006159254, "avg_wps": 376.95435806443845, "eta_in_seconds": 42681.793314748335, "at": "2024-05-25T20:39:19.639300"} +{"lr": 2.017871714788541e-05, "step": 10, "loss": 1.80855131149292, "percent_done": 2.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138387203216553, "wps": 5580.081971151358, "avg_wps": 415.71781837213734, "eta_in_seconds": 38623.12196016312, "at": "2024-05-25T20:39:25.512825"} +{"lr": 2.37460115010474e-05, "step": 11, "loss": 2.021888494491577, "percent_done": 2.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.13830804824829, "wps": 5553.936144684694, "avg_wps": 453.89217074522264, "eta_in_seconds": 35302.55208784883, "at": "2024-05-25T20:39:31.413986"} +{"lr": 2.7440845664062507e-05, "step": 12, "loss": 1.3890361785888672, "percent_done": 2.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.139437198638916, "wps": 5557.07418107636, "avg_wps": 491.505521031996, "eta_in_seconds": 32534.291713396706, "at": "2024-05-25T20:39:37.311790"} +{"lr": 3.12e-05, "step": 13, "loss": 1.787401556968689, "percent_done": 2.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138948917388916, "wps": 5569.582870646628, "avg_wps": 528.5771504011161, "eta_in_seconds": 30190.514266252518, "at": "2024-05-25T20:39:43.196397"} +{"lr": 3.495915433593748e-05, "step": 14, "loss": 2.1234130859375, "percent_done": 2.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137800693511963, "wps": 5572.508150605316, "avg_wps": 565.1135824739247, "eta_in_seconds": 28180.61447095871, "at": "2024-05-25T20:39:49.077853"} +{"lr": 3.86539884989526e-05, "step": 15, "loss": 1.9175409078598022, "percent_done": 3.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460636138916, "wps": 5557.726755664029, "avg_wps": 601.1130101154488, "eta_in_seconds": 26438.422946373623, "at": "2024-05-25T20:39:54.975005"} +{"lr": 4.222128285211459e-05, "step": 16, "loss": 1.3648927211761475, "percent_done": 3.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.139925479888916, "wps": 5556.00464081919, "avg_wps": 636.5955912499829, "eta_in_seconds": 24913.323651611805, "at": "2024-05-25T20:40:00.873970"} +{"lr": 4.56e-05, "step": 17, "loss": 2.056034564971924, "percent_done": 3.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460159301758, "wps": 5554.529840548538, "avg_wps": 671.5723277397101, "eta_in_seconds": 23566.998439718696, "at": "2024-05-25T20:40:06.774522"} +{"lr": 4.873232915545115e-05, "step": 18, "loss": 1.9965183734893799, "percent_done": 3.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460636138916, "wps": 5554.581247786527, "avg_wps": 706.0551091305251, "eta_in_seconds": 22369.607975006104, "at": "2024-05-25T20:40:12.674932"} +{"lr": 5.156467529817257e-05, "step": 19, "loss": 1.8671244382858276, "percent_done": 3.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460636138916, "wps": 5555.080553606147, "avg_wps": 740.0547517915678, "eta_in_seconds": 21297.624212051694, "at": "2024-05-25T20:40:18.574883"} +{"lr": 5.404857620038757e-05, "step": 20, "loss": 2.019505739212036, "percent_done": 4.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.139925479888916, "wps": 5555.889421920746, "avg_wps": 773.5817115992901, "eta_in_seconds": 20332.228340148926, "at": "2024-05-25T20:40:24.473975"} +{"lr": 5.6141531628991836e-05, "step": 21, "loss": 2.036513090133667, "percent_done": 4.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137901782989502, "wps": 5560.768731637014, "avg_wps": 806.649975199497, "eta_in_seconds": 19458.095186971485, "at": "2024-05-25T20:40:30.367881"} +{"lr": 5.780773053632506e-05, "step": 22, "loss": 1.6750460863113403, "percent_done": 4.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138948917388916, "wps": 5560.018946928277, "avg_wps": 839.2637477907966, "eta_in_seconds": 18662.910248691383, "at": "2024-05-25T20:40:36.262622"} +{"lr": 5.9018663797125166e-05, "step": 23, "loss": 1.6812807321548462, "percent_done": 4.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138154983520508, "wps": 5555.9267047060275, "avg_wps": 871.4286575799931, "eta_in_seconds": 17936.449374302574, "at": "2024-05-25T20:40:42.161668"} +{"lr": 5.975361200756574e-05, "step": 24, "loss": 1.570634126663208, "percent_done": 4.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138704776763916, "wps": 5543.589221105666, "avg_wps": 903.1442325298884, "eta_in_seconds": 17270.295749227207, "at": "2024-05-25T20:40:48.073857"} +{"lr": 6e-05, "step": 25, "loss": 1.8365230560302734, "percent_done": 5.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460636138916, "wps": 5562.553911307754, "avg_wps": 934.4536077093645, "eta_in_seconds": 16656.578637599945, "at": "2024-05-25T20:40:53.966078"} +{"lr": 5.9999343854031334e-05, "step": 26, "loss": 2.171419382095337, "percent_done": 5.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460636138916, "wps": 5561.219644640052, "avg_wps": 965.3434724806583, "eta_in_seconds": 16089.643160985066, "at": "2024-05-25T20:40:59.859472"} +{"lr": 5.999737544482728e-05, "step": 27, "loss": 2.036579132080078, "percent_done": 5.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137364387512207, "wps": 5548.8223771047, "avg_wps": 995.8088548703487, "eta_in_seconds": 15564.497066073947, "at": "2024-05-25T20:41:05.765977"} +{"lr": 5.999409485849245e-05, "step": 28, "loss": 1.7827755212783813, "percent_done": 5.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137972354888916, "wps": 5559.722508188558, "avg_wps": 1025.8851983292695, "eta_in_seconds": 15076.244423048836, "at": "2024-05-25T20:41:11.660892"} +{"lr": 5.9989502238530296e-05, "step": 29, "loss": 1.6104776859283447, "percent_done": 5.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460636138916, "wps": 5554.207949609566, "avg_wps": 1055.5608675047133, "eta_in_seconds": 14621.352946215662, "at": "2024-05-25T20:41:17.561652"} +{"lr": 5.99835977858369e-05, "step": 30, "loss": 1.3605297803878784, "percent_done": 6.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138704776763916, "wps": 5552.800507900883, "avg_wps": 1084.8483288581726, "eta_in_seconds": 14196.417683760325, "at": "2024-05-25T20:41:23.463908"} +{"lr": 5.9976381758692166e-05, "step": 31, "loss": 1.9134105443954468, "percent_done": 6.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137446403503418, "wps": 5557.846545814935, "avg_wps": 1113.7633423550844, "eta_in_seconds": 13798.435821656258, "at": "2024-05-25T20:41:29.360830"} +{"lr": 5.9967854472748474e-05, "step": 32, "loss": 1.8787431716918945, "percent_done": 6.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138948917388916, "wps": 5552.494968295918, "avg_wps": 1142.2998522335706, "eta_in_seconds": 13425.042443990707, "at": "2024-05-25T20:41:35.263435"} +{"lr": 5.9958016301016944e-05, "step": 33, "loss": 1.8014883995056152, "percent_done": 6.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137971878051758, "wps": 5548.536091011219, "avg_wps": 1170.4664500415147, "eta_in_seconds": 13073.980889804436, "at": "2024-05-25T20:41:41.170255"} +{"lr": 5.994686767385109e-05, "step": 34, "loss": 1.5512491464614868, "percent_done": 6.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460159301758, "wps": 5547.428186897443, "avg_wps": 1198.2737085743877, "eta_in_seconds": 12743.238786543117, "at": "2024-05-25T20:41:47.078230"} +{"lr": 5.993440907892797e-05, "step": 35, "loss": 1.941110372543335, "percent_done": 7.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.13756275177002, "wps": 5554.835155131593, "avg_wps": 1225.740191440962, "eta_in_seconds": 12430.954052414212, "at": "2024-05-25T20:41:52.978371"} +{"lr": 5.9920641061226885e-05, "step": 36, "loss": 1.9951637983322144, "percent_done": 7.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460636138916, "wps": 5556.571596388007, "avg_wps": 1252.8649653535003, "eta_in_seconds": 12135.666987631055, "at": "2024-05-25T20:41:58.876615"} +{"lr": 5.9905564223005546e-05, "step": 37, "loss": 1.25052011013031, "percent_done": 7.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460636138916, "wps": 5556.897580834897, "avg_wps": 1279.6525466810815, "eta_in_seconds": 11856.018291331626, "at": "2024-05-25T20:42:04.774525"} +{"lr": 5.988917922377368e-05, "step": 38, "loss": 1.6062840223312378, "percent_done": 7.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138704776763916, "wps": 5555.032954036967, "avg_wps": 1306.106035852241, "eta_in_seconds": 11590.801653498098, "at": "2024-05-25T20:42:10.674424"} +{"lr": 5.9871486780264246e-05, "step": 39, "loss": 2.4371840953826904, "percent_done": 7.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.13834285736084, "wps": 5545.017500061627, "avg_wps": 1332.2193844413002, "eta_in_seconds": 11339.009307641249, "at": "2024-05-25T20:42:16.584984"} +{"lr": 5.985248766640204e-05, "step": 40, "loss": 1.5869956016540527, "percent_done": 8.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138187408447266, "wps": 5561.712717545395, "avg_wps": 1358.037925618307, "eta_in_seconds": 11099.307107448578, "at": "2024-05-25T20:42:22.477832"} +{"lr": 5.983218271326983e-05, "step": 41, "loss": 1.577226996421814, "percent_done": 8.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138704776763916, "wps": 5534.343369641866, "avg_wps": 1383.5016531903127, "eta_in_seconds": 10871.336485444046, "at": "2024-05-25T20:42:28.399799"} +{"lr": 5.981057280907208e-05, "step": 42, "loss": 1.166637659072876, "percent_done": 8.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.139436721801758, "wps": 5540.272755380342, "avg_wps": 1408.6658846122555, "eta_in_seconds": 10653.870562167396, "at": "2024-05-25T20:42:34.315405"} +{"lr": 5.978765889909597e-05, "step": 43, "loss": 1.1755441427230835, "percent_done": 8.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137903690338135, "wps": 5564.49252919488, "avg_wps": 1433.5648176940954, "eta_in_seconds": 10445.97064267203, "at": "2024-05-25T20:42:40.205276"} +{"lr": 5.976344198567018e-05, "step": 44, "loss": 1.9575656652450562, "percent_done": 8.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.13865613937378, "wps": 5560.819579445251, "avg_wps": 1458.1614361535399, "eta_in_seconds": 10247.293358282608, "at": "2024-05-25T20:42:46.099048"} +{"lr": 5.9737923128120935e-05, "step": 45, "loss": 1.779711365699768, "percent_done": 9.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.13776206970215, "wps": 5550.597427659745, "avg_wps": 1482.4504474652838, "eta_in_seconds": 10057.294006347656, "at": "2024-05-25T20:42:52.003662"} +{"lr": 5.971110344272575e-05, "step": 46, "loss": 1.3091778755187988, "percent_done": 9.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.1381893157959, "wps": 5561.619092231965, "avg_wps": 1506.4704587706226, "eta_in_seconds": 9875.183355497276, "at": "2024-05-25T20:42:57.896584"} +{"lr": 5.968298410266454e-05, "step": 47, "loss": 1.6483534574508667, "percent_done": 9.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.13896656036377, "wps": 5553.744483217595, "avg_wps": 1530.1965433078512, "eta_in_seconds": 9700.65189659342, "at": "2024-05-25T20:43:03.797937"} +{"lr": 5.9653566337968336e-05, "step": 48, "loss": 1.8563672304153442, "percent_done": 9.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138216495513916, "wps": 5553.780166259074, "avg_wps": 1553.6461313314924, "eta_in_seconds": 9533.146384696165, "at": "2024-05-25T20:43:09.699213"} +{"lr": 5.9622851435465466e-05, "step": 49, "loss": 1.8628863096237183, "percent_done": 9.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137377738952637, "wps": 5548.785413624245, "avg_wps": 1576.815748807435, "eta_in_seconds": 9372.285894009532, "at": "2024-05-25T20:43:15.605774"} +{"lr": 5.9590840738725265e-05, "step": 50, "loss": 1.3155834674835205, "percent_done": 10.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460636138916, "wps": 5535.9147204855335, "avg_wps": 1599.696728711999, "eta_in_seconds": 9217.747173786163, "at": "2024-05-25T20:43:21.526093"} +{"lr": 5.955753564799931e-05, "step": 51, "loss": 2.009901523590088, "percent_done": 10.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138205528259277, "wps": 5548.248042647234, "avg_wps": 1622.3354768015533, "eta_in_seconds": 9068.920830731298, "at": "2024-05-25T20:43:27.433281"} +{"lr": 5.9522937620160167e-05, "step": 52, "loss": 1.6919968128204346, "percent_done": 10.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460636138916, "wps": 5549.996055612321, "avg_wps": 1644.7190624419832, "eta_in_seconds": 8925.575397784893, "at": "2024-05-25T20:43:33.338592"} +{"lr": 5.9487048168637646e-05, "step": 53, "loss": 1.1714354753494263, "percent_done": 10.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.139437198638916, "wps": 5554.831787508283, "avg_wps": 1666.8571901779799, "eta_in_seconds": 8787.373079295428, "at": "2024-05-25T20:43:39.238727"} +{"lr": 5.944986886335264e-05, "step": 54, "loss": 2.0765464305877686, "percent_done": 10.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138774871826172, "wps": 5531.156819108264, "avg_wps": 1688.705353919069, "eta_in_seconds": 8654.279425409106, "at": "2024-05-25T20:43:45.164134"} +{"lr": 5.941140133064838e-05, "step": 55, "loss": 1.370763897895813, "percent_done": 11.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138948917388916, "wps": 5561.254298665018, "avg_wps": 1710.3598945846343, "eta_in_seconds": 8525.550702030008, "at": "2024-05-25T20:43:51.057490"} +{"lr": 5.937164725321938e-05, "step": 56, "loss": 1.4677678346633911, "percent_done": 11.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137971878051758, "wps": 5536.07304191847, "avg_wps": 1731.7298047548293, "eta_in_seconds": 8401.421491997582, "at": "2024-05-25T20:43:56.977625"} +{"lr": 5.933060837003778e-05, "step": 57, "loss": 1.323209285736084, "percent_done": 11.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137247562408447, "wps": 5553.40540499479, "avg_wps": 1752.8926918827574, "eta_in_seconds": 8281.296434870937, "at": "2024-05-25T20:44:02.879221"} +{"lr": 5.928828647627726e-05, "step": 58, "loss": 2.137457847595215, "percent_done": 11.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138845920562744, "wps": 5537.1420600388055, "avg_wps": 1773.793795541985, "eta_in_seconds": 8165.242226238909, "at": "2024-05-25T20:44:08.798188"} +{"lr": 5.924468342323457e-05, "step": 59, "loss": 1.427688479423523, "percent_done": 11.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138704776763916, "wps": 5553.044604814879, "avg_wps": 1794.493513785876, "eta_in_seconds": 8052.794779688625, "at": "2024-05-25T20:44:14.700254"} +{"lr": 5.919980111824851e-05, "step": 60, "loss": 2.1419734954833984, "percent_done": 12.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138704299926758, "wps": 5549.771499097812, "avg_wps": 1814.9618832355695, "eta_in_seconds": 7943.92440589269, "at": "2024-05-25T20:44:20.605746"} +{"lr": 5.915364152461648e-05, "step": 61, "loss": 1.7291948795318604, "percent_done": 12.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137971878051758, "wps": 5545.189095131542, "avg_wps": 1835.200112791118, "eta_in_seconds": 7838.465080585636, "at": "2024-05-25T20:44:26.516177"} +{"lr": 5.9106206661508645e-05, "step": 62, "loss": 1.7408125400543213, "percent_done": 12.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137239933013916, "wps": 5535.932559067549, "avg_wps": 1855.203184353124, "eta_in_seconds": 7736.286850437042, "at": "2024-05-25T20:44:32.436449"} +{"lr": 5.90574986038796e-05, "step": 63, "loss": 1.5607613325119019, "percent_done": 12.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137972354888916, "wps": 5555.616329545631, "avg_wps": 1875.0268936808773, "eta_in_seconds": 7637.018993305781, "at": "2024-05-25T20:44:38.335781"} +{"lr": 5.9007519482377565e-05, "step": 64, "loss": 1.6699544191360474, "percent_done": 12.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137474536895752, "wps": 5548.115227932228, "avg_wps": 1894.6256876666519, "eta_in_seconds": 7540.723264232278, "at": "2024-05-25T20:44:44.243073"} +{"lr": 5.8956271483251227e-05, "step": 65, "loss": 1.5331006050109863, "percent_done": 13.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137239933013916, "wps": 5554.4885358589745, "avg_wps": 1914.0280981442897, "eta_in_seconds": 7447.163400484965, "at": "2024-05-25T20:44:50.143637"} +{"lr": 5.8903756848254094e-05, "step": 66, "loss": 1.560412049293518, "percent_done": 13.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.13801670074463, "wps": 5553.710595973772, "avg_wps": 1933.224445416171, "eta_in_seconds": 7356.265349178603, "at": "2024-05-25T20:44:56.045063"} +{"lr": 5.884997787454641e-05, "step": 67, "loss": 1.9336748123168945, "percent_done": 13.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.139436721801758, "wps": 5541.384729046641, "avg_wps": 1952.1965829270116, "eta_in_seconds": 7267.98936341058, "at": "2024-05-25T20:45:01.959622"} +{"lr": 5.879493691459472e-05, "step": 68, "loss": 2.1178951263427734, "percent_done": 13.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137239456176758, "wps": 5552.80566781582, "avg_wps": 1970.9914529447676, "eta_in_seconds": 7182.058541578406, "at": "2024-05-25T20:45:07.862052"} +{"lr": 5.873863637606892e-05, "step": 69, "loss": 1.7240588665008545, "percent_done": 13.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460636138916, "wps": 5543.99061257771, "avg_wps": 1989.5746993998691, "eta_in_seconds": 7098.5060295851345, "at": "2024-05-25T20:45:13.773822"} +{"lr": 5.868107872173695e-05, "step": 70, "loss": 1.5420374870300293, "percent_done": 14.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.1373929977417, "wps": 5554.931919918968, "avg_wps": 2007.9861061213974, "eta_in_seconds": 7017.1003459862295, "at": "2024-05-25T20:45:19.673939"} +{"lr": 5.862226646935706e-05, "step": 71, "loss": 1.9585456848144531, "percent_done": 14.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137856483459473, "wps": 5552.514259816822, "avg_wps": 2026.2038052632013, "eta_in_seconds": 6937.837133404236, "at": "2024-05-25T20:45:25.576530"} +{"lr": 5.856220219156771e-05, "step": 72, "loss": 1.4345052242279053, "percent_done": 14.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.13765525817871, "wps": 5545.524933162883, "avg_wps": 2044.2220217479744, "eta_in_seconds": 6860.655961434046, "at": "2024-05-25T20:45:31.486611"} +{"lr": 5.8500888515774985e-05, "step": 73, "loss": 1.588839054107666, "percent_done": 14.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137439250946045, "wps": 5558.762560526928, "avg_wps": 2062.0816921440924, "eta_in_seconds": 6785.345145784012, "at": "2024-05-25T20:45:37.382575"} +{"lr": 5.84383281240377e-05, "step": 74, "loss": 1.6788491010665894, "percent_done": 14.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138704299926758, "wps": 5532.457990374883, "avg_wps": 2079.7107728268707, "eta_in_seconds": 6712.071785359769, "at": "2024-05-25T20:45:43.306594"} +{"lr": 5.8374523752950034e-05, "step": 75, "loss": 1.5148811340332031, "percent_done": 15.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138948917388916, "wps": 5566.7571611282665, "avg_wps": 2097.2269616127014, "eta_in_seconds": 6640.387642780939, "at": "2024-05-25T20:45:49.194058"} +{"lr": 5.830947819352191e-05, "step": 76, "loss": 1.5197645425796509, "percent_done": 15.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137753009796143, "wps": 5562.889604457081, "avg_wps": 2114.5607068441673, "eta_in_seconds": 6570.457852087523, "at": "2024-05-25T20:45:55.085624"} +{"lr": 5.8243194291056786e-05, "step": 77, "loss": 1.343898057937622, "percent_done": 15.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.13804578781128, "wps": 5555.037220002813, "avg_wps": 2131.706926992656, "eta_in_seconds": 6502.237162382571, "at": "2024-05-25T20:46:00.985557"} +{"lr": 5.817567494502731e-05, "step": 78, "loss": 1.9336332082748413, "percent_done": 15.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138948440551758, "wps": 5553.7776976062205, "avg_wps": 2148.6806757662603, "eta_in_seconds": 6435.621707757314, "at": "2024-05-25T20:46:06.886879"} +{"lr": 5.810692310894839e-05, "step": 79, "loss": 1.5035141706466675, "percent_done": 15.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137239933013916, "wps": 5539.445654295171, "avg_wps": 2165.459220931015, "eta_in_seconds": 6370.624700135822, "at": "2024-05-25T20:46:12.803436"} +{"lr": 5.8036941790248074e-05, "step": 80, "loss": 1.4708526134490967, "percent_done": 16.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138343334197998, "wps": 5563.196964699215, "avg_wps": 2182.118405648204, "eta_in_seconds": 6306.972144305706, "at": "2024-05-25T20:46:18.694794"} +{"lr": 5.796573405013595e-05, "step": 81, "loss": 1.5440717935562134, "percent_done": 16.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138198852539062, "wps": 5556.627085181227, "avg_wps": 2198.6023433935015, "eta_in_seconds": 6244.781845728557, "at": "2024-05-25T20:46:24.593107"} +{"lr": 5.7893303003469235e-05, "step": 82, "loss": 1.469053030014038, "percent_done": 16.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137239456176758, "wps": 5552.443375352151, "avg_wps": 2214.9179083891677, "eta_in_seconds": 6183.987202469895, "at": "2024-05-25T20:46:30.495863"} +{"lr": 5.7819651818616575e-05, "step": 83, "loss": 1.9670883417129517, "percent_done": 16.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.13767910003662, "wps": 5559.290951695647, "avg_wps": 2231.0888040444484, "eta_in_seconds": 6124.4787635659595, "at": "2024-05-25T20:46:36.391358"} +{"lr": 5.774478371731938e-05, "step": 84, "loss": 1.1487362384796143, "percent_done": 16.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137346267700195, "wps": 5559.2306875430095, "avg_wps": 2247.1039541846408, "eta_in_seconds": 6066.24716876802, "at": "2024-05-25T20:46:42.286960"} +{"lr": 5.766870197455095e-05, "step": 85, "loss": 1.2741221189498901, "percent_done": 17.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137903690338135, "wps": 5561.889849056914, "avg_wps": 2262.9708927706633, "eta_in_seconds": 6009.233279775171, "at": "2024-05-25T20:46:48.179708"} +{"lr": 5.759140991837317e-05, "step": 86, "loss": 1.429990291595459, "percent_done": 17.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460636138916, "wps": 5559.723632706748, "avg_wps": 2278.682424373464, "eta_in_seconds": 5953.419333424678, "at": "2024-05-25T20:46:54.074779"} +{"lr": 5.751291092979098e-05, "step": 87, "loss": 1.8114343881607056, "percent_done": 17.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138948917388916, "wps": 5559.919305797688, "avg_wps": 2294.2452944901015, "eta_in_seconds": 5898.7519915597195, "at": "2024-05-25T20:46:59.969578"} +{"lr": 5.743320844260443e-05, "step": 88, "loss": 1.9716078042984009, "percent_done": 17.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137906074523926, "wps": 5559.70474086154, "avg_wps": 2309.66081168639, "eta_in_seconds": 5845.194208470258, "at": "2024-05-25T20:47:05.864638"} +{"lr": 5.735230594325853e-05, "step": 89, "loss": 1.7522364854812622, "percent_done": 17.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.139925479888916, "wps": 5556.521050881002, "avg_wps": 2324.925207198632, "eta_in_seconds": 5792.723119995568, "at": "2024-05-25T20:47:11.763060"} +{"lr": 5.727020697069067e-05, "step": 90, "loss": 1.2205445766448975, "percent_done": 18.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138633728027344, "wps": 5546.019255131338, "avg_wps": 2340.026015995776, "eta_in_seconds": 5741.337877511978, "at": "2024-05-25T20:47:17.686171"} +{"lr": 5.718691511617588e-05, "step": 91, "loss": 1.3227550983428955, "percent_done": 18.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138216495513916, "wps": 5564.7689733587085, "avg_wps": 2355.0229234196768, "eta_in_seconds": 5690.862652215329, "at": "2024-05-25T20:47:23.575901"} +{"lr": 5.7102434023169716e-05, "step": 92, "loss": 1.351460337638855, "percent_done": 18.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138911247253418, "wps": 5525.344877253915, "avg_wps": 2369.80271612768, "eta_in_seconds": 5641.543031837629, "at": "2024-05-25T20:47:29.507500"} +{"lr": 5.701676738714885e-05, "step": 93, "loss": 1.3369505405426025, "percent_done": 18.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137972354888916, "wps": 5563.356625290101, "avg_wps": 2384.5209447417615, "eta_in_seconds": 5592.9791807487445, "at": "2024-05-25T20:47:35.398627"} +{"lr": 5.6929918955449466e-05, "step": 94, "loss": 1.2744086980819702, "percent_done": 18.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138543605804443, "wps": 5531.966750791252, "avg_wps": 2399.0416810787615, "eta_in_seconds": 5545.467636067817, "at": "2024-05-25T20:47:41.323208"} +{"lr": 5.6841892527103325e-05, "step": 95, "loss": 1.3447908163070679, "percent_done": 19.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.139925479888916, "wps": 5541.495325355869, "avg_wps": 2413.4481076092898, "eta_in_seconds": 5498.788210178676, "at": "2024-05-25T20:47:47.237630"} +{"lr": 5.675269195267157e-05, "step": 96, "loss": 1.9318268299102783, "percent_done": 19.2, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.13810396194458, "wps": 5553.018130031148, "avg_wps": 2427.746035512088, "eta_in_seconds": 5452.906443407138, "at": "2024-05-25T20:47:53.139772"} +{"lr": 5.6662321134076275e-05, "step": 97, "loss": 1.1247085332870483, "percent_done": 19.4, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137335777282715, "wps": 5561.727571851196, "avg_wps": 2441.9316610965197, "eta_in_seconds": 5407.810632206731, "at": "2024-05-25T20:47:59.032666"} +{"lr": 5.657078402442983e-05, "step": 98, "loss": 1.6976115703582764, "percent_done": 19.6, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.138460159301758, "wps": 5543.270385517951, "avg_wps": 2455.9525982864475, "eta_in_seconds": 5363.5953760633665, "at": "2024-05-25T20:48:04.945197"} +{"lr": 5.6478084627861946e-05, "step": 99, "loss": 1.7711162567138672, "percent_done": 19.8, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.137407779693604, "wps": 5544.969625365944, "avg_wps": 2469.8507370666402, "eta_in_seconds": 5320.146599468559, "at": "2024-05-25T20:48:10.855932"} +{"lr": 5.638422699934453e-05, "step": 100, "loss": 1.1657578945159912, "percent_done": 20.0, "peak_allocated_mem": 40.33880138397217, "allocated_mem": 20.13837957382202, "wps": 5563.056227772297, "avg_wps": 2483.6605425272455, "eta_in_seconds": 5277.37175655365, "at": "2024-05-25T20:48:16.747447"} +{"lr": 5.62892152445143e-05, "step": 101, "loss": 1.2271069288253784, "percent_done": 20.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137747764587402, "wps": 5650.647283285913, "avg_wps": 2497.5196603768695, "eta_in_seconds": 5234.966598031544, "at": "2024-05-25T20:48:37.367433"} +{"lr": 5.619305351949323e-05, "step": 102, "loss": 1.5706729888916016, "percent_done": 20.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138704776763916, "wps": 5593.43703296185, "avg_wps": 2511.1461006529644, "eta_in_seconds": 5193.51064305212, "at": "2024-05-25T20:48:43.226830"} +{"lr": 5.609574603070667e-05, "step": 103, "loss": 1.691847562789917, "percent_done": 20.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.13744354248047, "wps": 5603.0124359367655, "avg_wps": 2524.672022286429, "eta_in_seconds": 5152.707316104648, "at": "2024-05-25T20:48:49.076232"} +{"lr": 5.599729703469942e-05, "step": 104, "loss": 1.9103899002075195, "percent_done": 20.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138948917388916, "wps": 5581.8832018598405, "avg_wps": 2538.038270485687, "eta_in_seconds": 5112.660494877742, "at": "2024-05-25T20:48:54.947796"} +{"lr": 5.589771083794951e-05, "step": 105, "loss": 1.6460245847702026, "percent_done": 21.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.13742685317993, "wps": 5584.214425065317, "avg_wps": 2551.292788213583, "eta_in_seconds": 5073.255433400472, "at": "2024-05-25T20:49:00.816884"} +{"lr": 5.579699179667977e-05, "step": 106, "loss": 1.2260392904281616, "percent_done": 21.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.13933801651001, "wps": 5580.816328592392, "avg_wps": 2564.4256948355073, "eta_in_seconds": 5034.496427796921, "at": "2024-05-25T20:49:06.689556"} +{"lr": 5.569514431666738e-05, "step": 107, "loss": 1.879921317100525, "percent_done": 21.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137972354888916, "wps": 2108.589851573107, "avg_wps": 2559.255032852445, "eta_in_seconds": 5031.8642865564225, "at": "2024-05-25T20:49:22.230808"} +{"lr": 5.559217285305104e-05, "step": 108, "loss": 2.019869327545166, "percent_done": 21.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138010501861572, "wps": 5599.157083828909, "avg_wps": 2572.1855375131227, "eta_in_seconds": 4993.8294935049835, "at": "2024-05-25T20:49:28.084265"} +{"lr": 5.548808191013616e-05, "step": 109, "loss": 1.4541178941726685, "percent_done": 21.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138704299926758, "wps": 5568.556115643228, "avg_wps": 2584.9463391452978, "eta_in_seconds": 4956.500568687369, "at": "2024-05-25T20:49:33.969860"} +{"lr": 5.538287604119777e-05, "step": 110, "loss": 1.805503010749817, "percent_done": 22.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137971878051758, "wps": 5575.0683136446005, "avg_wps": 2597.6117788299935, "eta_in_seconds": 4919.71899117123, "at": "2024-05-25T20:49:39.848564"} +{"lr": 5.5276559848281426e-05, "step": 111, "loss": 1.5910478830337524, "percent_done": 22.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138046741485596, "wps": 5574.644772769438, "avg_wps": 2610.1695390900495, "eta_in_seconds": 4883.495807112874, "at": "2024-05-25T20:49:45.727702"} +{"lr": 5.516913798200181e-05, "step": 112, "loss": 1.4546467065811157, "percent_done": 22.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460636138916, "wps": 5580.191172211638, "avg_wps": 2622.6327513818974, "eta_in_seconds": 4847.794260672161, "at": "2024-05-25T20:49:51.601012"} +{"lr": 5.506061514133933e-05, "step": 113, "loss": 1.9278520345687866, "percent_done": 22.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.13832664489746, "wps": 5556.368072083266, "avg_wps": 2634.9445914722564, "eta_in_seconds": 4812.706893739447, "at": "2024-05-25T20:49:57.499483"} +{"lr": 5.495099607343464e-05, "step": 114, "loss": 1.2954063415527344, "percent_done": 22.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137250900268555, "wps": 5562.699350850223, "avg_wps": 2647.1661179129605, "eta_in_seconds": 4778.1089046168745, "at": "2024-05-25T20:50:03.391154"} +{"lr": 5.4840285573380864e-05, "step": 115, "loss": 1.9585537910461426, "percent_done": 23.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.139925479888916, "wps": 5576.940307212868, "avg_wps": 2659.3142631404876, "eta_in_seconds": 4743.95981507716, "at": "2024-05-25T20:50:09.267962"} +{"lr": 5.4728488484013935e-05, "step": 116, "loss": 1.3559701442718506, "percent_done": 23.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137749671936035, "wps": 5559.850706192177, "avg_wps": 2671.3281752927132, "eta_in_seconds": 4710.357984608617, "at": "2024-05-25T20:50:15.162762"} +{"lr": 5.46156096957007e-05, "step": 117, "loss": 1.4577502012252808, "percent_done": 23.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138704299926758, "wps": 5534.631759025195, "avg_wps": 2683.1925442184743, "eta_in_seconds": 4677.317707609926, "at": "2024-05-25T20:50:21.084330"} +{"lr": 5.450165414612506e-05, "step": 118, "loss": 2.0765445232391357, "percent_done": 23.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.139925479888916, "wps": 5555.676739937697, "avg_wps": 2695.0011227702, "eta_in_seconds": 4644.664484270548, "at": "2024-05-25T20:50:26.983614"} +{"lr": 5.43866268200719e-05, "step": 119, "loss": 1.4534521102905273, "percent_done": 23.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.139391899108887, "wps": 5555.78858123143, "avg_wps": 2706.71323343397, "eta_in_seconds": 4612.460546535604, "at": "2024-05-25T20:50:32.882796"} +{"lr": 5.42705327492091e-05, "step": 120, "loss": 1.727876901626587, "percent_done": 24.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137362480163574, "wps": 5554.861198223078, "avg_wps": 2718.3279855754854, "eta_in_seconds": 4580.698159337044, "at": "2024-05-25T20:50:38.782876"} +{"lr": 5.415337701186742e-05, "step": 121, "loss": 1.3772063255310059, "percent_done": 24.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460636138916, "wps": 5558.715347481607, "avg_wps": 2729.85607979915, "eta_in_seconds": 4549.350455469336, "at": "2024-05-25T20:50:44.678973"} +{"lr": 5.403516473281833e-05, "step": 122, "loss": 1.3952522277832031, "percent_done": 24.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.13841962814331, "wps": 5544.7756741932135, "avg_wps": 2741.263118262313, "eta_in_seconds": 4518.465928163684, "at": "2024-05-25T20:50:50.589781"} +{"lr": 5.391590108304989e-05, "step": 123, "loss": 1.6238394975662231, "percent_done": 24.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138002395629883, "wps": 5555.707956231327, "avg_wps": 2752.5999399893826, "eta_in_seconds": 4487.951852548413, "at": "2024-05-25T20:50:56.489120"} +{"lr": 5.3795591279540496e-05, "step": 124, "loss": 2.1171414852142334, "percent_done": 24.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.139925479888916, "wps": 5557.831936983476, "avg_wps": 2763.8500343041696, "eta_in_seconds": 4457.827974411749, "at": "2024-05-25T20:51:02.386146"} +{"lr": 5.3674240585030686e-05, "step": 125, "loss": 1.7309659719467163, "percent_done": 25.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137933254241943, "wps": 5565.31247912587, "avg_wps": 2775.0251534443346, "eta_in_seconds": 4428.067970752716, "at": "2024-05-25T20:51:08.275110"} +{"lr": 5.3551854307792975e-05, "step": 126, "loss": 1.2059592008590698, "percent_done": 25.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460636138916, "wps": 5564.331001187206, "avg_wps": 2786.1095184754154, "eta_in_seconds": 4398.6899720676365, "at": "2024-05-25T20:51:14.165313"} +{"lr": 5.3428437801399596e-05, "step": 127, "loss": 1.6496320962905884, "percent_done": 25.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138370037078857, "wps": 5540.607774792897, "avg_wps": 2797.058732866275, "eta_in_seconds": 4369.755935541288, "at": "2024-05-25T20:51:20.080515"} +{"lr": 5.3303996464488364e-05, "step": 128, "loss": 1.433815598487854, "percent_done": 25.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137948989868164, "wps": 5556.206341545806, "avg_wps": 2807.9524564075905, "eta_in_seconds": 4341.133330866694, "at": "2024-05-25T20:51:25.979307"} +{"lr": 5.317853574052649e-05, "step": 129, "loss": 0.9737545847892761, "percent_done": 25.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138704776763916, "wps": 5551.068664463455, "avg_wps": 2818.7502368444966, "eta_in_seconds": 4312.878750693891, "at": "2024-05-25T20:51:31.883491"} +{"lr": 5.3052061117572476e-05, "step": 130, "loss": 1.666468858718872, "percent_done": 26.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137904167175293, "wps": 5553.650901570001, "avg_wps": 2829.468501866808, "eta_in_seconds": 4284.960229103382, "at": "2024-05-25T20:51:37.784808"} +{"lr": 5.292457812803603e-05, "step": 131, "loss": 1.3377872705459595, "percent_done": 26.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.13762664794922, "wps": 5568.723981120164, "avg_wps": 2840.1330938275382, "eta_in_seconds": 4257.3328786169295, "at": "2024-05-25T20:51:43.670331"} +{"lr": 5.2796092348436136e-05, "step": 132, "loss": 1.5446778535842896, "percent_done": 26.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137971878051758, "wps": 5558.88396918339, "avg_wps": 2850.6953984480515, "eta_in_seconds": 4230.0640070366135, "at": "2024-05-25T20:51:49.566100"} +{"lr": 5.266660939915699e-05, "step": 133, "loss": 1.560217261314392, "percent_done": 26.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138086795806885, "wps": 5550.925850188886, "avg_wps": 2861.160077671213, "eta_in_seconds": 4203.139871079223, "at": "2024-05-25T20:51:55.470654"} +{"lr": 5.25361349442023e-05, "step": 134, "loss": 1.3033735752105713, "percent_done": 26.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137972354888916, "wps": 5566.850508552111, "avg_wps": 2871.575670970398, "eta_in_seconds": 4176.483357635896, "at": "2024-05-25T20:52:01.358227"} +{"lr": 5.240467469094738e-05, "step": 135, "loss": 1.6556729078292847, "percent_done": 27.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460636138916, "wps": 5555.222009970131, "avg_wps": 2881.8882485826707, "eta_in_seconds": 4150.16786507324, "at": "2024-05-25T20:52:07.257858"} +{"lr": 5.227223438988959e-05, "step": 136, "loss": 1.4874310493469238, "percent_done": 27.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138094902038574, "wps": 5566.695833123898, "avg_wps": 2892.1446918558554, "eta_in_seconds": 4124.120080709457, "at": "2024-05-25T20:52:13.145448"} +{"lr": 5.2138819834396735e-05, "step": 137, "loss": 1.4221686124801636, "percent_done": 27.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.13765573501587, "wps": 5570.277893974724, "avg_wps": 2902.330173285688, "eta_in_seconds": 4098.356592742196, "at": "2024-05-25T20:52:19.029112"} +{"lr": 5.200443686045369e-05, "step": 138, "loss": 1.346228003501892, "percent_done": 27.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.139925479888916, "wps": 5554.16440516483, "avg_wps": 2912.4064605670196, "eta_in_seconds": 4072.9260014381957, "at": "2024-05-25T20:52:24.929959"} +{"lr": 5.1869091346407056e-05, "step": 139, "loss": 1.3880159854888916, "percent_done": 27.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460636138916, "wps": 5552.394699410316, "avg_wps": 2922.4029372331215, "eta_in_seconds": 4047.7813135514157, "at": "2024-05-25T20:52:30.832631"} +{"lr": 5.1732789212708097e-05, "step": 140, "loss": 1.413693904876709, "percent_done": 28.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460636138916, "wps": 5563.298524888907, "avg_wps": 2932.3456752387624, "eta_in_seconds": 4022.8817835535324, "at": "2024-05-25T20:52:36.723687"} +{"lr": 5.159553642165368e-05, "step": 141, "loss": 1.2220680713653564, "percent_done": 28.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137972354888916, "wps": 5563.031233638689, "avg_wps": 2942.2132967617686, "eta_in_seconds": 3998.2526123946445, "at": "2024-05-25T20:52:42.615163"} +{"lr": 5.145733897712554e-05, "step": 142, "loss": 2.0723164081573486, "percent_done": 28.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137526988983154, "wps": 5555.450825276103, "avg_wps": 2951.9921162105907, "eta_in_seconds": 3973.907631927813, "at": "2024-05-25T20:52:48.514535"} +{"lr": 5.131820292432759e-05, "step": 143, "loss": 1.3057760000228882, "percent_done": 28.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137376308441162, "wps": 5575.348071338388, "avg_wps": 2961.7374283307677, "eta_in_seconds": 3949.768094936451, "at": "2024-05-25T20:52:54.392938"} +{"lr": 5.117813434952152e-05, "step": 144, "loss": 1.5901497602462769, "percent_done": 28.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138704776763916, "wps": 5548.617404010489, "avg_wps": 2971.35762460369, "eta_in_seconds": 3925.952198889521, "at": "2024-05-25T20:53:00.299617"} +{"lr": 5.103713937976054e-05, "step": 145, "loss": 1.9550269842147827, "percent_done": 29.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.13754367828369, "wps": 5548.909075200079, "avg_wps": 2980.9071145504277, "eta_in_seconds": 3902.382581201093, "at": "2024-05-25T20:53:06.205977"} +{"lr": 5.0895224182621414e-05, "step": 146, "loss": 1.5265612602233887, "percent_done": 29.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138047695159912, "wps": 5567.461402664203, "avg_wps": 2990.422888913616, "eta_in_seconds": 3879.007227708216, "at": "2024-05-25T20:53:12.092681"} +{"lr": 5.075239496593458e-05, "step": 147, "loss": 1.3615673780441284, "percent_done": 29.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137654304504395, "wps": 5559.7987515519235, "avg_wps": 2999.853749302408, "eta_in_seconds": 3855.8893088337513, "at": "2024-05-25T20:53:17.987429"} +{"lr": 5.0608657977512685e-05, "step": 148, "loss": 1.4289532899856567, "percent_done": 29.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460159301758, "wps": 5548.987934735265, "avg_wps": 3009.1941910448254, "eta_in_seconds": 3833.0314588289007, "at": "2024-05-25T20:53:23.893710"} +{"lr": 5.0464019504877256e-05, "step": 149, "loss": 1.4397034645080566, "percent_done": 29.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137972354888916, "wps": 5562.26890788203, "avg_wps": 3018.4927449210863, "eta_in_seconds": 3810.3679458406946, "at": "2024-05-25T20:53:29.785980"} +{"lr": 5.031848587498364e-05, "step": 150, "loss": 1.6799601316452026, "percent_done": 30.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.13797950744629, "wps": 5548.615163951038, "avg_wps": 3027.696775432237, "eta_in_seconds": 3787.961890061696, "at": "2024-05-25T20:53:35.692661"} +{"lr": 5.017206345394427e-05, "step": 151, "loss": 1.963998794555664, "percent_done": 30.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137452602386475, "wps": 5555.257936543063, "avg_wps": 3036.8472463470825, "eta_in_seconds": 3765.758061672678, "at": "2024-05-25T20:53:41.592440"} +{"lr": 5.00247586467502e-05, "step": 152, "loss": 0.65717613697052, "percent_done": 30.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138099193572998, "wps": 5561.224595188606, "avg_wps": 3045.9434901841396, "eta_in_seconds": 3743.754287217793, "at": "2024-05-25T20:53:47.485902"} +{"lr": 4.987657789699088e-05, "step": 153, "loss": 1.5457826852798462, "percent_done": 30.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.139925479888916, "wps": 5553.937940170815, "avg_wps": 3054.9600246964533, "eta_in_seconds": 3721.9786537566215, "at": "2024-05-25T20:53:53.387082"} +{"lr": 4.9727527686572356e-05, "step": 154, "loss": 2.111055850982666, "percent_done": 30.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460159301758, "wps": 5541.489069285229, "avg_wps": 3063.8873039837435, "eta_in_seconds": 3700.438976739908, "at": "2024-05-25T20:53:59.301664"} +{"lr": 4.957761453543368e-05, "step": 155, "loss": 1.6042062044143677, "percent_done": 31.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137933254241943, "wps": 5558.52717774068, "avg_wps": 3072.7844049311666, "eta_in_seconds": 3679.0605881291053, "at": "2024-05-25T20:54:05.197945"} +{"lr": 4.942684500126173e-05, "step": 156, "loss": 1.6236882209777832, "percent_done": 31.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137380123138428, "wps": 5564.622974974392, "avg_wps": 3081.6302655430277, "eta_in_seconds": 3657.8664630987705, "at": "2024-05-25T20:54:11.087908"} +{"lr": 4.927522567920438e-05, "step": 157, "loss": 1.7616581916809082, "percent_done": 31.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.1374192237854, "wps": 5570.051467521558, "avg_wps": 3090.4241980511615, "eta_in_seconds": 3636.854774528248, "at": "2024-05-25T20:54:16.972004"} +{"lr": 4.9122763201581924e-05, "step": 158, "loss": 1.5534157752990723, "percent_done": 31.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.139925003051758, "wps": 5553.008258142508, "avg_wps": 3099.1226992716292, "eta_in_seconds": 3616.0736722795273, "at": "2024-05-25T20:54:22.874022"} +{"lr": 4.8969464237597066e-05, "step": 159, "loss": 1.4567362070083618, "percent_done": 31.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460636138916, "wps": 5561.143812338777, "avg_wps": 3107.775968708241, "eta_in_seconds": 3595.461227742381, "at": "2024-05-25T20:54:28.767659"} +{"lr": 4.8815335493043095e-05, "step": 160, "loss": 1.50173819065094, "percent_done": 32.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137432098388672, "wps": 5561.656677015134, "avg_wps": 3116.3696303633938, "eta_in_seconds": 3575.0316302180295, "at": "2024-05-25T20:54:34.660563"} +{"lr": 4.866038371001062e-05, "step": 161, "loss": 1.492889165878296, "percent_done": 32.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138216495513916, "wps": 5555.554797634425, "avg_wps": 3124.891333053958, "eta_in_seconds": 3554.7962524328173, "at": "2024-05-25T20:54:40.560097"} +{"lr": 4.850461566659259e-05, "step": 162, "loss": 1.9640576839447021, "percent_done": 32.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.139079093933105, "wps": 5553.556874265973, "avg_wps": 3133.349774558509, "eta_in_seconds": 3534.742303565696, "at": "2024-05-25T20:54:46.461671"} +{"lr": 4.834803817658786e-05, "step": 163, "loss": 1.4579799175262451, "percent_done": 32.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.139925479888916, "wps": 5556.233071360178, "avg_wps": 3141.7547552001165, "eta_in_seconds": 3514.8561426452334, "at": "2024-05-25T20:54:52.360313"} +{"lr": 4.819065808920307e-05, "step": 164, "loss": 1.3637343645095825, "percent_done": 32.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460636138916, "wps": 5547.105775201019, "avg_wps": 3150.0837053361083, "eta_in_seconds": 3495.1604560061196, "at": "2024-05-25T20:54:58.268913"} +{"lr": 4.803248228875308e-05, "step": 165, "loss": 1.3648020029067993, "percent_done": 33.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138075351715088, "wps": 5555.44274119532, "avg_wps": 3158.371529083776, "eta_in_seconds": 3475.6139038476076, "at": "2024-05-25T20:55:04.168342"} +{"lr": 4.7873517694359834e-05, "step": 166, "loss": 1.2300453186035156, "percent_done": 33.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460636138916, "wps": 5546.490834035293, "avg_wps": 3166.5848873366767, "eta_in_seconds": 3456.2509420693636, "at": "2024-05-25T20:55:10.077539"} +{"lr": 4.7713771259649654e-05, "step": 167, "loss": 1.4588795900344849, "percent_done": 33.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138948917388916, "wps": 5562.773199225658, "avg_wps": 3174.7737937427323, "eta_in_seconds": 3437.0146375487666, "at": "2024-05-25T20:55:15.969356"} +{"lr": 4.755324997244911e-05, "step": 168, "loss": 1.4031540155410767, "percent_done": 33.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460636138916, "wps": 5554.236904798709, "avg_wps": 3182.8902594855676, "eta_in_seconds": 3417.955101524081, "at": "2024-05-25T20:55:21.870066"} +{"lr": 4.739196085447931e-05, "step": 169, "loss": 1.2381229400634766, "percent_done": 33.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137545108795166, "wps": 5557.902509587597, "avg_wps": 3190.958696397348, "eta_in_seconds": 3399.0436830929752, "at": "2024-05-25T20:55:27.767137"} +{"lr": 4.722991096104879e-05, "step": 170, "loss": 1.3746353387832642, "percent_done": 34.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138204097747803, "wps": 5561.745127042168, "avg_wps": 3198.979981463478, "eta_in_seconds": 3380.277483028524, "at": "2024-05-25T20:55:33.660029"} +{"lr": 4.706710738074485e-05, "step": 171, "loss": 1.6288833618164062, "percent_done": 34.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138704299926758, "wps": 5541.889039359204, "avg_wps": 3206.908427121632, "eta_in_seconds": 3361.7024760748213, "at": "2024-05-25T20:55:39.574012"} +{"lr": 4.6903557235123503e-05, "step": 172, "loss": 1.3765610456466675, "percent_done": 34.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137418270111084, "wps": 5556.240259253299, "avg_wps": 3214.811398312738, "eta_in_seconds": 3343.24558063995, "at": "2024-05-25T20:55:45.472742"} +{"lr": 4.673926767839795e-05, "step": 173, "loss": 1.636695384979248, "percent_done": 34.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.13822889328003, "wps": 5556.802769560052, "avg_wps": 3222.662471516406, "eta_in_seconds": 3324.9327519422322, "at": "2024-05-25T20:55:51.370748"} +{"lr": 4.6574245897125624e-05, "step": 174, "loss": 1.2106655836105347, "percent_done": 34.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460636138916, "wps": 5551.186822487211, "avg_wps": 3230.4501629893657, "eta_in_seconds": 3306.773812017221, "at": "2024-05-25T20:55:57.274930"} +{"lr": 4.640849910989384e-05, "step": 175, "loss": 1.542215347290039, "percent_done": 35.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137919902801514, "wps": 5558.062315961587, "avg_wps": 3238.1992891010864, "eta_in_seconds": 3288.74138038499, "at": "2024-05-25T20:56:03.171640"} +{"lr": 4.6242034567004e-05, "step": 176, "loss": 1.2512855529785156, "percent_done": 35.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460636138916, "wps": 5555.841808488788, "avg_wps": 3245.8926847511702, "eta_in_seconds": 3270.8512052405963, "at": "2024-05-25T20:56:09.070882"} +{"lr": 4.60748595501545e-05, "step": 177, "loss": 1.5124765634536743, "percent_done": 35.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460636138916, "wps": 5539.491200952619, "avg_wps": 3253.503400831597, "eta_in_seconds": 3253.1283038753577, "at": "2024-05-25T20:56:14.987441"} +{"lr": 4.590698137212215e-05, "step": 178, "loss": 1.5872209072113037, "percent_done": 35.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138948917388916, "wps": 5555.507639063067, "avg_wps": 3261.0948694422227, "eta_in_seconds": 3235.5072214764155, "at": "2024-05-25T20:56:20.886787"} +{"lr": 4.5738407376442294e-05, "step": 179, "loss": 1.6335300207138062, "percent_done": 35.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137239933013916, "wps": 5552.848966610332, "avg_wps": 3268.631288827209, "eta_in_seconds": 3218.022184378608, "at": "2024-05-25T20:56:26.789184"} +{"lr": 4.5569144937087604e-05, "step": 180, "loss": 1.1790390014648438, "percent_done": 36.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137638568878174, "wps": 5556.54755907667, "avg_wps": 3276.1254513884023, "eta_in_seconds": 3200.6588745117188, "at": "2024-05-25T20:56:32.687572"} +{"lr": 4.5399201458145525e-05, "step": 181, "loss": 1.5353507995605469, "percent_done": 36.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137362480163574, "wps": 5561.656226894965, "avg_wps": 3283.5805265968797, "eta_in_seconds": 3183.4127152756437, "at": "2024-05-25T20:56:38.580435"} +{"lr": 4.522858437349436e-05, "step": 182, "loss": 1.0730583667755127, "percent_done": 36.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.13727378845215, "wps": 5564.029822682039, "avg_wps": 3290.991689662758, "eta_in_seconds": 3166.2869379861017, "at": "2024-05-25T20:56:44.470978"} +{"lr": 4.505730114647811e-05, "step": 183, "loss": 1.2952125072479248, "percent_done": 36.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.139925479888916, "wps": 5556.725035715289, "avg_wps": 3298.3407925181355, "eta_in_seconds": 3149.2973750810156, "at": "2024-05-25T20:56:50.369157"} +{"lr": 4.488535926958002e-05, "step": 184, "loss": 1.8670090436935425, "percent_done": 36.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137972354888916, "wps": 5549.96826519811, "avg_wps": 3305.629363266546, "eta_in_seconds": 3132.4407131257262, "at": "2024-05-25T20:56:56.274537"} +{"lr": 4.471276626409479e-05, "step": 185, "loss": 1.4453619718551636, "percent_done": 37.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.13893413543701, "wps": 5542.104689638564, "avg_wps": 3312.855733051561, "eta_in_seconds": 3115.716720477955, "at": "2024-05-25T20:57:02.188239"} +{"lr": 4.45395296797996e-05, "step": 186, "loss": 1.043641448020935, "percent_done": 37.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137971878051758, "wps": 5554.1022320637485, "avg_wps": 3320.0586526436173, "eta_in_seconds": 3099.087418774123, "at": "2024-05-25T20:57:08.089082"} +{"lr": 4.4365657094623857e-05, "step": 187, "loss": 1.7168866395950317, "percent_done": 37.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137845516204834, "wps": 5557.737318565426, "avg_wps": 3327.222394518049, "eta_in_seconds": 3082.566412422109, "at": "2024-05-25T20:57:13.986258"} +{"lr": 4.419115611431772e-05, "step": 188, "loss": 1.8670060634613037, "percent_done": 37.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138948917388916, "wps": 5564.732473044407, "avg_wps": 3334.353790290621, "eta_in_seconds": 3066.1461389521337, "at": "2024-05-25T20:57:19.875840"} +{"lr": 4.401603437211934e-05, "step": 189, "loss": 1.5417808294296265, "percent_done": 37.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.137972354888916, "wps": 5567.39870599123, "avg_wps": 3341.444956119956, "eta_in_seconds": 3049.8326723398986, "at": "2024-05-25T20:57:25.762851"} +{"lr": 4.384029952842108e-05, "step": 190, "loss": 1.4005597829818726, "percent_done": 38.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.139925479888916, "wps": 5551.42180823028, "avg_wps": 3348.4607222862705, "eta_in_seconds": 3033.6566089579933, "at": "2024-05-25T20:57:31.666685"} +{"lr": 4.366395927043427e-05, "step": 191, "loss": 1.5885343551635742, "percent_done": 38.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138704776763916, "wps": 5552.8889008121405, "avg_wps": 3355.4348905018346, "eta_in_seconds": 3017.585597819683, "at": "2024-05-25T20:57:37.568935"} +{"lr": 4.348702131185308e-05, "step": 192, "loss": 1.7843871116638184, "percent_done": 38.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.13781976699829, "wps": 5556.887470473756, "avg_wps": 3362.3726997502135, "eta_in_seconds": 3001.6137118736906, "at": "2024-05-25T20:57:43.466958"} +{"lr": 4.3309493392517e-05, "step": 193, "loss": 1.0619243383407593, "percent_done": 38.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138704776763916, "wps": 5547.189732971251, "avg_wps": 3369.248413312876, "eta_in_seconds": 2985.762628914779, "at": "2024-05-25T20:57:49.375152"} +{"lr": 4.313138327807234e-05, "step": 194, "loss": 1.829172968864441, "percent_done": 38.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138704299926758, "wps": 5503.900172971312, "avg_wps": 3375.9976847966323, "eta_in_seconds": 2970.087344892246, "at": "2024-05-25T20:57:55.330092"} +{"lr": 4.2952698759632504e-05, "step": 195, "loss": 1.6749804019927979, "percent_done": 39.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138460159301758, "wps": 5557.033287909847, "avg_wps": 3382.806354759786, "eta_in_seconds": 2954.422734229993, "at": "2024-05-25T20:58:01.227977"} +{"lr": 4.277344765343719e-05, "step": 196, "loss": 1.3518160581588745, "percent_done": 39.2, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138704776763916, "wps": 5565.223915598104, "avg_wps": 3389.5881717954044, "eta_in_seconds": 2938.844335984211, "at": "2024-05-25T20:58:07.117045"} +{"lr": 4.2593637800510475e-05, "step": 197, "loss": 1.479128122329712, "percent_done": 39.4, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138704776763916, "wps": 5552.388643016425, "avg_wps": 3396.303649071369, "eta_in_seconds": 2923.3852522917814, "at": "2024-05-25T20:58:13.019953"} +{"lr": 4.241327706631782e-05, "step": 198, "loss": 1.6236207485198975, "percent_done": 39.6, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.139925479888916, "wps": 5575.682369975144, "avg_wps": 3403.0215592232116, "eta_in_seconds": 2907.9851031736894, "at": "2024-05-25T20:58:18.897956"} +{"lr": 4.223237334042203e-05, "step": 199, "loss": 1.6376577615737915, "percent_done": 39.8, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.13769817352295, "wps": 5559.7380265797465, "avg_wps": 3409.6681319358927, "eta_in_seconds": 2892.7061574171535, "at": "2024-05-25T20:58:24.793001"} +{"lr": 4.205093453613813e-05, "step": 200, "loss": 1.1267300844192505, "percent_done": 40.0, "peak_allocated_mem": 46.97310400009155, "allocated_mem": 20.138704776763916, "wps": 5545.982105194007, "avg_wps": 3416.247830389426, "eta_in_seconds": 2877.542991042137, "at": "2024-05-25T20:58:30.702617"} +{"lr": 4.186896859018719e-05, "step": 201, "loss": 1.7362898588180542, "percent_done": 40.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138370513916016, "wps": 5631.634516593391, "avg_wps": 3422.9469725373733, "eta_in_seconds": 2862.3382362062066, "at": "2024-05-25T20:58:50.847032"} +{"lr": 4.1686483462349175e-05, "step": 202, "loss": 1.387878179550171, "percent_done": 40.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5623.079212131215, "avg_wps": 3429.5899903517834, "eta_in_seconds": 2847.2394739519254, "at": "2024-05-25T20:58:56.675734"} +{"lr": 4.1503487135114756e-05, "step": 203, "loss": 1.2791255712509155, "percent_done": 40.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138065814971924, "wps": 5593.452284851494, "avg_wps": 3436.1382255458716, "eta_in_seconds": 2832.277213892913, "at": "2024-05-25T20:59:02.535188"} +{"lr": 4.1319987613336105e-05, "step": 204, "loss": 1.546048641204834, "percent_done": 40.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13805341720581, "wps": 5586.331879496734, "avg_wps": 3442.6337091672945, "eta_in_seconds": 2817.415043073542, "at": "2024-05-25T20:59:08.401993"} +{"lr": 4.113599292387675e-05, "step": 205, "loss": 1.8863822221755981, "percent_done": 41.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139436721801758, "wps": 5565.583595689993, "avg_wps": 3449.051341465809, "eta_in_seconds": 2802.672109801595, "at": "2024-05-25T20:59:14.290941"} +{"lr": 4.095151111526049e-05, "step": 206, "loss": 1.8544223308563232, "percent_done": 41.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137451648712158, "wps": 5575.394210308197, "avg_wps": 3455.4486151965743, "eta_in_seconds": 2788.0003648822744, "at": "2024-05-25T20:59:20.169317"} +{"lr": 4.076655025731926e-05, "step": 207, "loss": 1.0614246129989624, "percent_done": 41.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5571.623739027438, "avg_wps": 3461.8004839169125, "eta_in_seconds": 2773.4192206064863, "at": "2024-05-25T20:59:26.051778"} +{"lr": 4.058111844084018e-05, "step": 208, "loss": 1.712361216545105, "percent_done": 41.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5572.7105994825015, "avg_wps": 3468.1163596464075, "eta_in_seconds": 2758.9201190976, "at": "2024-05-25T20:59:31.933071"} +{"lr": 4.0395223777211613e-05, "step": 209, "loss": 1.361742377281189, "percent_done": 41.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5569.720778012922, "avg_wps": 3474.3889901147613, "eta_in_seconds": 2744.5078910651964, "at": "2024-05-25T20:59:37.817402"} +{"lr": 4.020887439806836e-05, "step": 210, "loss": 1.1486153602600098, "percent_done": 42.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139925479888916, "wps": 5543.862250431524, "avg_wps": 3480.575977238469, "eta_in_seconds": 2730.2147869041987, "at": "2024-05-25T20:59:43.729424"} +{"lr": 4.0022078454935966e-05, "step": 211, "loss": 1.664003849029541, "percent_done": 42.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139437198638916, "wps": 5554.218948056706, "avg_wps": 3486.7454603118376, "eta_in_seconds": 2715.9860413650763, "at": "2024-05-25T20:59:49.630291"} +{"lr": 3.9834844118874095e-05, "step": 212, "loss": 1.5402318239212036, "percent_done": 42.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139925479888916, "wps": 5566.816686660078, "avg_wps": 3492.901789012356, "eta_in_seconds": 2701.817734952243, "at": "2024-05-25T20:59:55.517789"} +{"lr": 3.964717958011919e-05, "step": 213, "loss": 1.7210785150527954, "percent_done": 42.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137370586395264, "wps": 5567.542820235499, "avg_wps": 3499.0231304871086, "eta_in_seconds": 2687.72615935545, "at": "2024-05-25T21:00:01.404577"} +{"lr": 3.9459093047726116e-05, "step": 214, "loss": 1.1239063739776611, "percent_done": 42.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13736391067505, "wps": 5566.792786104201, "avg_wps": 3505.1070662096877, "eta_in_seconds": 2673.712335450627, "at": "2024-05-25T21:00:07.292191"} +{"lr": 3.92705927492091e-05, "step": 215, "loss": 1.0822852849960327, "percent_done": 43.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5559.072387933016, "avg_wps": 3511.1410006603946, "eta_in_seconds": 2659.7849525961765, "at": "2024-05-25T21:00:13.187889"} +{"lr": 3.908168693018187e-05, "step": 216, "loss": 1.1669790744781494, "percent_done": 43.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460159301758, "wps": 5553.440634887874, "avg_wps": 3517.129139889429, "eta_in_seconds": 2645.9398076843336, "at": "2024-05-25T21:00:19.089571"} +{"lr": 3.889238385399692e-05, "step": 217, "loss": 1.324610710144043, "percent_done": 43.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137738704681396, "wps": 5570.474988016133, "avg_wps": 3523.1137630503454, "eta_in_seconds": 2632.1443540247906, "at": "2024-05-25T21:00:24.973202"} +{"lr": 3.870269180138406e-05, "step": 218, "loss": 1.8057652711868286, "percent_done": 43.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137910842895508, "wps": 5550.222199248679, "avg_wps": 3529.026179237957, "eta_in_seconds": 2618.449263528946, "at": "2024-05-25T21:00:30.878355"} +{"lr": 3.851261907008817e-05, "step": 219, "loss": 1.2189598083496094, "percent_done": 43.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13731098175049, "wps": 5564.601120937185, "avg_wps": 3534.930770712089, "eta_in_seconds": 2604.80575073473, "at": "2024-05-25T21:00:36.768199"} +{"lr": 3.8322173974506286e-05, "step": 220, "loss": 1.7741843461990356, "percent_done": 44.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13759422302246, "wps": 5554.064075976166, "avg_wps": 3540.78177730296, "eta_in_seconds": 2591.246955351396, "at": "2024-05-25T21:00:42.669222"} +{"lr": 3.813136484532385e-05, "step": 221, "loss": 1.7000113725662231, "percent_done": 44.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138413906097412, "wps": 5564.706562618062, "avg_wps": 3546.618570563268, "eta_in_seconds": 2577.743227275788, "at": "2024-05-25T21:00:48.559005"} +{"lr": 3.794020002915029e-05, "step": 222, "loss": 1.4811164140701294, "percent_done": 44.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5566.482999355986, "avg_wps": 3552.425055236727, "eta_in_seconds": 2564.305751242079, "at": "2024-05-25T21:00:54.446868"} +{"lr": 3.774868788815397e-05, "step": 223, "loss": 1.0256524085998535, "percent_done": 44.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137866020202637, "wps": 5568.419168375546, "avg_wps": 3558.2017983011065, "eta_in_seconds": 2550.9334530531028, "at": "2024-05-25T21:01:00.332647"} +{"lr": 3.755683679969634e-05, "step": 224, "loss": 1.5768307447433472, "percent_done": 44.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13749361038208, "wps": 5563.479585954795, "avg_wps": 3563.936488774755, "eta_in_seconds": 2537.634446765695, "at": "2024-05-25T21:01:06.223694"} +{"lr": 3.736465515596552e-05, "step": 225, "loss": 1.3924486637115479, "percent_done": 45.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139925479888916, "wps": 5565.33028231268, "avg_wps": 3569.6418577060645, "eta_in_seconds": 2524.398905886544, "at": "2024-05-25T21:01:12.112775"} +{"lr": 3.717215136360919e-05, "step": 226, "loss": 1.490935206413269, "percent_done": 45.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5552.80993036148, "avg_wps": 3575.291874995275, "eta_in_seconds": 2511.244484063798, "at": "2024-05-25T21:01:18.015116"} +{"lr": 3.697933384336687e-05, "step": 227, "loss": 1.415578842163086, "percent_done": 45.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138020992279053, "wps": 5569.118865894443, "avg_wps": 3580.9395815021176, "eta_in_seconds": 2498.1331844329834, "at": "2024-05-25T21:01:23.900071"} +{"lr": 3.6786211029701516e-05, "step": 228, "loss": 1.7322523593902588, "percent_done": 45.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137834072113037, "wps": 1800.504489269336, "avg_wps": 3565.4758397596906, "eta_in_seconds": 2499.7774211816622, "at": "2024-05-25T21:01:42.100628"} +{"lr": 3.659279137043063e-05, "step": 229, "loss": 1.2511661052703857, "percent_done": 45.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137239933013916, "wps": 5617.396989912232, "avg_wps": 3571.1722448524133, "eta_in_seconds": 2486.614307892895, "at": "2024-05-25T21:01:47.935148"} +{"lr": 3.639908332635672e-05, "step": 230, "loss": 1.4502466917037964, "percent_done": 46.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139437198638916, "wps": 5586.757879475918, "avg_wps": 3576.7828038962693, "eta_in_seconds": 2473.552486989809, "at": "2024-05-25T21:01:53.801619"} +{"lr": 3.6205095370897137e-05, "step": 231, "loss": 1.7017109394073486, "percent_done": 46.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5577.714809075446, "avg_wps": 3582.346092460726, "eta_in_seconds": 2460.5640472736195, "at": "2024-05-25T21:01:59.677595"} +{"lr": 3.601083598971351e-05, "step": 232, "loss": 1.402816653251648, "percent_done": 46.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5575.641428678123, "avg_wps": 3587.8748317752284, "eta_in_seconds": 2447.6394555979764, "at": "2024-05-25T21:02:05.555781"} +{"lr": 3.581631368034047e-05, "step": 233, "loss": 1.5799578428268433, "percent_done": 46.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137860774993896, "wps": 5587.63324535373, "avg_wps": 3593.394317261015, "eta_in_seconds": 2434.760905023297, "at": "2024-05-25T21:02:11.421292"} +{"lr": 3.5621536951813995e-05, "step": 234, "loss": 1.6762008666992188, "percent_done": 46.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137831687927246, "wps": 5575.8282706463715, "avg_wps": 3598.862445963837, "eta_in_seconds": 2421.956418416439, "at": "2024-05-25T21:02:17.299356"} +{"lr": 3.542651432429918e-05, "step": 235, "loss": 1.4905848503112793, "percent_done": 47.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5568.48279048586, "avg_wps": 3604.287414113473, "eta_in_seconds": 2409.2196327067436, "at": "2024-05-25T21:02:23.184970"} +{"lr": 3.523125432871754e-05, "step": 236, "loss": 1.608702540397644, "percent_done": 47.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5571.589407380904, "avg_wps": 3609.688108518826, "eta_in_seconds": 2396.53724641315, "at": "2024-05-25T21:02:29.067539"} +{"lr": 3.503576550637384e-05, "step": 237, "loss": 1.5249228477478027, "percent_done": 47.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137239933013916, "wps": 5566.861782607451, "avg_wps": 3615.05082687209, "eta_in_seconds": 2383.9177961037635, "at": "2024-05-25T21:02:34.954986"} +{"lr": 3.484005640858246e-05, "step": 238, "loss": 1.2464808225631714, "percent_done": 47.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138176441192627, "wps": 5555.1667737706985, "avg_wps": 3620.3634106740283, "eta_in_seconds": 2371.368568881219, "at": "2024-05-25T21:02:40.854737"} +{"lr": 3.464413559629336e-05, "step": 239, "loss": 1.5430020093917847, "percent_done": 47.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137454986572266, "wps": 5563.946255367646, "avg_wps": 3625.662602205839, "eta_in_seconds": 2358.8648306096447, "at": "2024-05-25T21:02:46.745379"} +{"lr": 3.444801163971754e-05, "step": 240, "loss": 1.927183985710144, "percent_done": 48.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138210773468018, "wps": 5550.285854497728, "avg_wps": 3630.9086767996473, "eta_in_seconds": 2346.431915084521, "at": "2024-05-25T21:02:52.650436"} +{"lr": 3.4251693117952235e-05, "step": 241, "loss": 1.0613906383514404, "percent_done": 48.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137939929962158, "wps": 5561.046380993247, "avg_wps": 3636.1453560103846, "eta_in_seconds": 2334.0409057001852, "at": "2024-05-25T21:02:58.544066"} +{"lr": 3.4055188618605555e-05, "step": 242, "loss": 1.1775891780853271, "percent_done": 48.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137239933013916, "wps": 5560.073604866622, "avg_wps": 3641.3519729187174, "eta_in_seconds": 2321.704702779281, "at": "2024-05-25T21:03:04.438736"} +{"lr": 3.3858506737420905e-05, "step": 243, "loss": 1.864639401435852, "percent_done": 48.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138262271881104, "wps": 5562.521717514508, "avg_wps": 3646.534816594156, "eta_in_seconds": 2309.4187834645495, "at": "2024-05-25T21:03:10.330799"} +{"lr": 3.366165607790091e-05, "step": 244, "loss": 1.2012643814086914, "percent_done": 48.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460159301758, "wps": 5549.914253979481, "avg_wps": 3651.667452930919, "eta_in_seconds": 2297.1993228099386, "at": "2024-05-25T21:03:16.236251"} +{"lr": 3.3464645250931154e-05, "step": 245, "loss": 1.422299861907959, "percent_done": 49.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137317657470703, "wps": 5556.428948099429, "avg_wps": 3656.7840128351427, "eta_in_seconds": 2285.0242099810616, "at": "2024-05-25T21:03:22.134856"} +{"lr": 3.3267482874403404e-05, "step": 246, "loss": 1.5226637125015259, "percent_done": 49.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5560.339037295862, "avg_wps": 3661.880056845006, "eta_in_seconds": 2272.8958542598943, "at": "2024-05-25T21:03:28.029191"} +{"lr": 3.3070177572838744e-05, "step": 247, "loss": 1.6080811023712158, "percent_done": 49.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137378215789795, "wps": 5564.036355003768, "avg_wps": 3666.955394195295, "eta_in_seconds": 2260.813974755013, "at": "2024-05-25T21:03:33.919588"} +{"lr": 3.287273797701024e-05, "step": 248, "loss": 1.3393136262893677, "percent_done": 49.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460159301758, "wps": 5552.413765921801, "avg_wps": 3671.9832653335307, "eta_in_seconds": 2248.79456231671, "at": "2024-05-25T21:03:39.822254"} +{"lr": 3.267517272356543e-05, "step": 249, "loss": 1.6100767850875854, "percent_done": 49.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137292861938477, "wps": 5556.44691913412, "avg_wps": 3676.9914908129094, "eta_in_seconds": 2236.819971041507, "at": "2024-05-25T21:03:45.720835"} +{"lr": 3.247749045464852e-05, "step": 250, "loss": 1.4209333658218384, "percent_done": 50.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5553.2983716921535, "avg_wps": 3681.9676334534993, "eta_in_seconds": 2224.8973417282104, "at": "2024-05-25T21:03:51.622640"} +{"lr": 3.227969981752235e-05, "step": 251, "loss": 1.0997568368911743, "percent_done": 50.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137993335723877, "wps": 5571.039932751393, "avg_wps": 3686.9485086407403, "eta_in_seconds": 2213.0040549462533, "at": "2024-05-25T21:03:57.505712"} +{"lr": 3.208180946419016e-05, "step": 252, "loss": 1.9284535646438599, "percent_done": 50.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5562.985749395217, "avg_wps": 3691.889130521792, "eta_in_seconds": 2201.1668586730957, "at": "2024-05-25T21:04:03.397334"} +{"lr": 3.188382805101706e-05, "step": 253, "loss": 1.4230724573135376, "percent_done": 50.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5554.863667839257, "avg_wps": 3696.7896004346776, "eta_in_seconds": 2189.385081327951, "at": "2024-05-25T21:04:09.297407"} +{"lr": 3.168576423835144e-05, "step": 254, "loss": 1.4384173154830933, "percent_done": 50.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5559.426775696011, "avg_wps": 3701.672328164539, "eta_in_seconds": 2177.64493595709, "at": "2024-05-25T21:04:15.192805"} +{"lr": 3.148762669014611e-05, "step": 255, "loss": 1.6453195810317993, "percent_done": 51.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13813066482544, "wps": 5564.883434239453, "avg_wps": 3706.539026075164, "eta_in_seconds": 2165.9450888072743, "at": "2024-05-25T21:04:21.082377"} +{"lr": 3.12894240735793e-05, "step": 256, "loss": 1.2982429265975952, "percent_done": 51.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13790464401245, "wps": 5567.545526677654, "avg_wps": 3711.3849897547866, "eta_in_seconds": 2154.2879604436457, "at": "2024-05-25T21:04:26.969006"} +{"lr": 3.109116505867555e-05, "step": 257, "loss": 1.3471225500106812, "percent_done": 51.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137290477752686, "wps": 5567.729796469245, "avg_wps": 3716.206101140044, "eta_in_seconds": 2142.6755630042303, "at": "2024-05-25T21:04:32.855573"} +{"lr": 3.089285831792642e-05, "step": 258, "loss": 1.5243827104568481, "percent_done": 51.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138116359710693, "wps": 5554.059362613492, "avg_wps": 3720.9785114155975, "eta_in_seconds": 2131.1211488246918, "at": "2024-05-25T21:04:38.756488"} +{"lr": 3.0694512525911205e-05, "step": 259, "loss": 1.4718371629714966, "percent_done": 51.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137442111968994, "wps": 5564.76288993974, "avg_wps": 3725.74476124074, "eta_in_seconds": 2119.5998400518793, "at": "2024-05-25T21:04:44.646295"} +{"lr": 3.0496136358917387e-05, "step": 260, "loss": 1.8549796342849731, "percent_done": 52.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5563.799624448762, "avg_wps": 3730.4847674704356, "eta_in_seconds": 2108.1228017807007, "at": "2024-05-25T21:04:50.536949"} +{"lr": 3.029773849456115e-05, "step": 261, "loss": 1.777504801750183, "percent_done": 52.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13795232772827, "wps": 5556.207464642074, "avg_wps": 3735.1872612910765, "eta_in_seconds": 2096.695949132415, "at": "2024-05-25T21:04:56.435531"} +{"lr": 3.009932761140782e-05, "step": 262, "loss": 1.2974411249160767, "percent_done": 52.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137971878051758, "wps": 5552.8880034080385, "avg_wps": 3739.859849474659, "eta_in_seconds": 2085.314507466236, "at": "2024-05-25T21:05:02.337769"} +{"lr": 2.9900912388592177e-05, "step": 263, "loss": 1.4065451622009277, "percent_done": 52.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138948917388916, "wps": 5560.903502861799, "avg_wps": 3744.5223154158307, "eta_in_seconds": 2073.9670766623753, "at": "2024-05-25T21:05:08.231361"} +{"lr": 2.9702501505438846e-05, "step": 264, "loss": 1.5881295204162598, "percent_done": 52.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5553.439064118789, "avg_wps": 3749.148098230628, "eta_in_seconds": 2062.668050816565, "at": "2024-05-25T21:05:14.133022"} +{"lr": 2.9504103641082615e-05, "step": 265, "loss": 1.1610537767410278, "percent_done": 53.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138216495513916, "wps": 5570.269540927101, "avg_wps": 3753.77921304595, "eta_in_seconds": 2051.393958717022, "at": "2024-05-25T21:05:20.016791"} +{"lr": 2.93057274740888e-05, "step": 266, "loss": 1.0392107963562012, "percent_done": 53.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137577533721924, "wps": 5556.677407960057, "avg_wps": 3758.3635144774685, "eta_in_seconds": 2040.173062148847, "at": "2024-05-25T21:05:25.914849"} +{"lr": 2.9107381682073582e-05, "step": 267, "loss": 1.4900647401809692, "percent_done": 53.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5562.33486579308, "avg_wps": 3762.934268773554, "eta_in_seconds": 2028.9868104681093, "at": "2024-05-25T21:05:31.807275"} +{"lr": 2.8909074941324465e-05, "step": 268, "loss": 1.7403438091278076, "percent_done": 53.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137971878051758, "wps": 5556.721216478391, "avg_wps": 3767.4723004700622, "eta_in_seconds": 2017.8452271703463, "at": "2024-05-25T21:05:37.705369"} +{"lr": 2.8710815926420708e-05, "step": 269, "loss": 1.6407498121261597, "percent_done": 53.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138258934020996, "wps": 5555.646422290471, "avg_wps": 3771.985587478839, "eta_in_seconds": 2006.7436167112514, "at": "2024-05-25T21:05:43.604517"} +{"lr": 2.851261330985389e-05, "step": 270, "loss": 1.5581716299057007, "percent_done": 54.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138078689575195, "wps": 5556.534304947221, "avg_wps": 3776.4776683400414, "eta_in_seconds": 1995.6797476079728, "at": "2024-05-25T21:05:49.502867"} +{"lr": 2.8314475761648556e-05, "step": 271, "loss": 1.3138222694396973, "percent_done": 54.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138188362121582, "wps": 5557.412134457564, "avg_wps": 3780.9486905447584, "eta_in_seconds": 1984.6532217602887, "at": "2024-05-25T21:05:55.400139"} +{"lr": 2.811641194898294e-05, "step": 272, "loss": 1.473395586013794, "percent_done": 54.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138426303863525, "wps": 5565.342000928185, "avg_wps": 3785.4108269737258, "eta_in_seconds": 1973.6573760404306, "at": "2024-05-25T21:06:01.289182"} +{"lr": 2.7918430535809843e-05, "step": 273, "loss": 1.2150803804397583, "percent_done": 54.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5551.99455719416, "avg_wps": 3789.827975931032, "eta_in_seconds": 1962.7107212360088, "at": "2024-05-25T21:06:07.192283"} +{"lr": 2.772054018247765e-05, "step": 274, "loss": 1.8345710039138794, "percent_done": 54.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5561.284002458734, "avg_wps": 3794.238898268899, "eta_in_seconds": 1951.7927570081977, "at": "2024-05-25T21:06:13.085452"} +{"lr": 2.7522749545351488e-05, "step": 275, "loss": 1.971771240234375, "percent_done": 55.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138357162475586, "wps": 5560.162679365058, "avg_wps": 3798.6260060087475, "eta_in_seconds": 1940.9123162789776, "at": "2024-05-25T21:06:18.979978"} +{"lr": 2.7325067276434586e-05, "step": 276, "loss": 1.431512475013733, "percent_done": 55.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5562.965484377739, "avg_wps": 3802.9961182008947, "eta_in_seconds": 1930.065604030222, "at": "2024-05-25T21:06:24.871383"} +{"lr": 2.7127502022989765e-05, "step": 277, "loss": 1.4941389560699463, "percent_done": 55.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13831090927124, "wps": 5545.886099528511, "avg_wps": 3807.3156646077405, "eta_in_seconds": 1919.269281485451, "at": "2024-05-25T21:06:30.781070"} +{"lr": 2.693006242716126e-05, "step": 278, "loss": 1.3064836263656616, "percent_done": 55.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5569.411342372485, "avg_wps": 3811.653657409354, "eta_in_seconds": 1908.4881927452498, "at": "2024-05-25T21:06:36.665800"} +{"lr": 2.6732757125596597e-05, "step": 279, "loss": 1.7915124893188477, "percent_done": 55.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138948917388916, "wps": 5564.545472772144, "avg_wps": 3815.962149226363, "eta_in_seconds": 1897.7462869929584, "at": "2024-05-25T21:06:42.555566"} +{"lr": 2.653559474906885e-05, "step": 280, "loss": 1.1920902729034424, "percent_done": 56.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139925479888916, "wps": 5559.917956280929, "avg_wps": 3820.241716953686, "eta_in_seconds": 1887.0428978375026, "at": "2024-05-25T21:06:48.450429"} +{"lr": 2.6338583922099093e-05, "step": 281, "loss": 1.3190606832504272, "percent_done": 56.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13870334625244, "wps": 5551.798320180432, "avg_wps": 3824.4866401798195, "eta_in_seconds": 1876.380459695524, "at": "2024-05-25T21:06:54.353804"} +{"lr": 2.6141733262579107e-05, "step": 282, "loss": 1.2478429079055786, "percent_done": 56.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139437198638916, "wps": 5560.831054079251, "avg_wps": 3828.7260104879306, "eta_in_seconds": 1865.7443704334557, "at": "2024-05-25T21:07:00.247643"} +{"lr": 2.5945051381394456e-05, "step": 283, "loss": 2.0711076259613037, "percent_done": 56.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13743257522583, "wps": 5559.170424696916, "avg_wps": 3832.9419412563566, "eta_in_seconds": 1855.1431534778947, "at": "2024-05-25T21:07:06.143141"} +{"lr": 2.574854688204777e-05, "step": 284, "loss": 1.539806842803955, "percent_done": 56.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13786506652832, "wps": 5559.067890916699, "avg_wps": 3837.137207159814, "eta_in_seconds": 1844.5751657754604, "at": "2024-05-25T21:07:12.038758"} +{"lr": 2.555222836028246e-05, "step": 285, "loss": 1.5606036186218262, "percent_done": 57.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13929557800293, "wps": 5554.721331727097, "avg_wps": 3841.3048419504216, "eta_in_seconds": 1834.0434539485395, "at": "2024-05-25T21:07:17.938972"} +{"lr": 2.5356104403706647e-05, "step": 286, "loss": 1.3911527395248413, "percent_done": 57.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137815952301025, "wps": 5573.220853980137, "avg_wps": 3845.4831981371303, "eta_in_seconds": 1823.529486072647, "at": "2024-05-25T21:07:23.819540"} +{"lr": 2.5160183591417547e-05, "step": 287, "loss": 1.6155465841293335, "percent_done": 57.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5567.074194344783, "avg_wps": 3849.6312120409193, "eta_in_seconds": 1813.0526316830505, "at": "2024-05-25T21:07:29.706745"} +{"lr": 2.4964474493626167e-05, "step": 288, "loss": 1.6382837295532227, "percent_done": 57.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137314796447754, "wps": 5565.788021072726, "avg_wps": 3853.757144944917, "eta_in_seconds": 1802.608659217755, "at": "2024-05-25T21:07:35.595204"} +{"lr": 2.4768985671282466e-05, "step": 289, "loss": 1.9253641366958618, "percent_done": 57.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137473583221436, "wps": 5559.138494912464, "avg_wps": 3857.8522190009253, "eta_in_seconds": 1792.2013616660888, "at": "2024-05-25T21:07:41.490645"} +{"lr": 2.457372567570083e-05, "step": 290, "loss": 1.7776846885681152, "percent_done": 58.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137988567352295, "wps": 5559.695969691335, "avg_wps": 3861.928601080456, "eta_in_seconds": 1781.8247592860257, "at": "2024-05-25T21:07:47.385675"} +{"lr": 2.4378703048186006e-05, "step": 291, "loss": 1.6196858882904053, "percent_done": 58.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.1378755569458, "wps": 5573.536363647792, "avg_wps": 3866.0084418877236, "eta_in_seconds": 1771.4684545944647, "at": "2024-05-25T21:07:53.265883"} +{"lr": 2.4183926319659536e-05, "step": 292, "loss": 1.2948068380355835, "percent_done": 58.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138948440551758, "wps": 5560.521705518532, "avg_wps": 3870.047339634742, "eta_in_seconds": 1761.15261697116, "at": "2024-05-25T21:07:59.159995"} +{"lr": 2.3989404010286496e-05, "step": 293, "loss": 1.4295412302017212, "percent_done": 58.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13788890838623, "wps": 5562.366607188337, "avg_wps": 3874.0700849959712, "eta_in_seconds": 1750.8655886918611, "at": "2024-05-25T21:08:05.052120"} +{"lr": 2.379514462910286e-05, "step": 294, "loss": 1.884488821029663, "percent_done": 58.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5561.08508310515, "avg_wps": 3878.0716317924484, "eta_in_seconds": 1740.6094164588826, "at": "2024-05-25T21:08:10.945512"} +{"lr": 2.3601156673643287e-05, "step": 295, "loss": 1.561650037765503, "percent_done": 59.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139436721801758, "wps": 5541.894402478711, "avg_wps": 3882.0224299425554, "eta_in_seconds": 1730.3970085766357, "at": "2024-05-25T21:08:16.859483"} +{"lr": 2.340744862956937e-05, "step": 296, "loss": 1.1581376791000366, "percent_done": 59.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138704776763916, "wps": 5564.979648110344, "avg_wps": 3885.992697406539, "eta_in_seconds": 1720.1967477862897, "at": "2024-05-25T21:08:22.748913"} +{"lr": 2.3214028970298496e-05, "step": 297, "loss": 1.469279170036316, "percent_done": 59.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13864803314209, "wps": 5552.1710702214405, "avg_wps": 3889.923156012948, "eta_in_seconds": 1710.0348087127763, "at": "2024-05-25T21:08:28.651763"} +{"lr": 2.3020906156633134e-05, "step": 298, "loss": 1.9210610389709473, "percent_done": 59.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13786745071411, "wps": 5556.646854735636, "avg_wps": 3893.8424959275135, "eta_in_seconds": 1699.8982385452962, "at": "2024-05-25T21:08:34.550071"} +{"lr": 2.2828088636390805e-05, "step": 299, "loss": 1.8363906145095825, "percent_done": 59.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139436721801758, "wps": 5539.46150623313, "avg_wps": 3897.7150781525106, "eta_in_seconds": 1689.8023246793841, "at": "2024-05-25T21:08:40.466492"} +{"lr": 2.2635584844034485e-05, "step": 300, "loss": 1.566605806350708, "percent_done": 60.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138367176055908, "wps": 5561.844158400456, "avg_wps": 3901.606339386578, "eta_in_seconds": 1679.718410809835, "at": "2024-05-25T21:08:46.359337"} +{"lr": 2.244340320030367e-05, "step": 301, "loss": 1.830176830291748, "percent_done": 60.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5638.459405265181, "avg_wps": 3905.603248282777, "eta_in_seconds": 1669.6094266275234, "at": "2024-05-25T21:09:06.859505"} +{"lr": 2.225155211184604e-05, "step": 302, "loss": 1.3539057970046997, "percent_done": 60.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138216495513916, "wps": 5612.095164610734, "avg_wps": 3909.5396361643634, "eta_in_seconds": 1659.546801874969, "at": "2024-05-25T21:09:12.699367"} +{"lr": 2.2060039970849715e-05, "step": 303, "loss": 1.3002429008483887, "percent_done": 60.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5592.262432096055, "avg_wps": 3913.4259648495763, "eta_in_seconds": 1649.525520089436, "at": "2024-05-25T21:09:18.560085"} +{"lr": 2.186887515467616e-05, "step": 304, "loss": 1.724923014640808, "percent_done": 60.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138723850250244, "wps": 5554.794519416285, "avg_wps": 3917.2335005752366, "eta_in_seconds": 1639.5571004528747, "at": "2024-05-25T21:09:24.460236"} +{"lr": 2.167806602549372e-05, "step": 305, "loss": 1.7100708484649658, "percent_done": 61.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138948440551758, "wps": 5581.0533762949935, "avg_wps": 3921.0661090638073, "eta_in_seconds": 1629.5976202058011, "at": "2024-05-25T21:09:30.332621"} +{"lr": 2.148762092991183e-05, "step": 306, "loss": 1.1106200218200684, "percent_done": 61.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138668537139893, "wps": 5553.119543283147, "avg_wps": 3924.835727638039, "eta_in_seconds": 1619.6835845217986, "at": "2024-05-25T21:09:36.234581"} +{"lr": 2.129754819861595e-05, "step": 307, "loss": 1.6616202592849731, "percent_done": 61.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13792085647583, "wps": 5585.4244618420435, "avg_wps": 3928.640334616879, "eta_in_seconds": 1609.7742377368168, "at": "2024-05-25T21:09:42.102274"} +{"lr": 2.1107856146003084e-05, "step": 308, "loss": 1.4892951250076294, "percent_done": 61.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460159301758, "wps": 5556.18927053843, "avg_wps": 3932.380250323105, "eta_in_seconds": 1599.9103849336698, "at": "2024-05-25T21:09:48.001019"} +{"lr": 2.0918553069818132e-05, "step": 309, "loss": 1.4284430742263794, "percent_done": 61.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5555.011848828643, "avg_wps": 3936.1011049744284, "eta_in_seconds": 1590.0729765529384, "at": "2024-05-25T21:09:53.901003"} +{"lr": 2.0729647250790905e-05, "step": 310, "loss": 1.5685471296310425, "percent_done": 62.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137721061706543, "wps": 5566.748593164099, "avg_wps": 3939.823938348611, "eta_in_seconds": 1580.2533558414827, "at": "2024-05-25T21:09:59.788512"} +{"lr": 2.0541146952273892e-05, "step": 311, "loss": 1.9407562017440796, "percent_done": 62.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137794971466064, "wps": 5562.140148140054, "avg_wps": 3943.522369170015, "eta_in_seconds": 1570.4619931707045, "at": "2024-05-25T21:10:05.680838"} +{"lr": 2.0353060419880816e-05, "step": 312, "loss": 2.09151291847229, "percent_done": 62.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138216018676758, "wps": 5553.733037810849, "avg_wps": 3947.1903848216475, "eta_in_seconds": 1560.7010048688985, "at": "2024-05-25T21:10:11.582108"} +{"lr": 2.01653958811259e-05, "step": 313, "loss": 1.7137953042984009, "percent_done": 62.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138704776763916, "wps": 5536.386366657552, "avg_wps": 3950.8135928461343, "eta_in_seconds": 1550.9757309470315, "at": "2024-05-25T21:10:17.501859"} +{"lr": 1.997816154506404e-05, "step": 314, "loss": 1.4165407419204712, "percent_done": 62.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5554.9889476138, "avg_wps": 3954.4504406736346, "eta_in_seconds": 1541.2629621833753, "at": "2024-05-25T21:10:23.424236"} +{"lr": 1.979136560193164e-05, "step": 315, "loss": 1.4428484439849854, "percent_done": 63.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139436721801758, "wps": 5542.517935872208, "avg_wps": 3958.0506905782618, "eta_in_seconds": 1531.582203944524, "at": "2024-05-25T21:10:29.337473"} +{"lr": 1.9605016222788395e-05, "step": 316, "loss": 1.5803790092468262, "percent_done": 63.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.1381573677063, "wps": 5563.927560058712, "avg_wps": 3961.669134905131, "eta_in_seconds": 1521.9120513819441, "at": "2024-05-25T21:10:35.227913"} +{"lr": 1.9419121559159824e-05, "step": 317, "loss": 1.242454171180725, "percent_done": 63.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5566.6446523311515, "avg_wps": 3965.2756606367093, "eta_in_seconds": 1512.2640928921264, "at": "2024-05-25T21:10:41.115480"} +{"lr": 1.9233689742680746e-05, "step": 318, "loss": 1.3435838222503662, "percent_done": 63.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138195037841797, "wps": 5560.872678149055, "avg_wps": 3968.856778140613, "eta_in_seconds": 1502.6432883259636, "at": "2024-05-25T21:10:47.009188"} +{"lr": 1.9048728884739516e-05, "step": 319, "loss": 1.7093671560287476, "percent_done": 63.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138440132141113, "wps": 5560.1755009293465, "avg_wps": 3972.4207415001338, "eta_in_seconds": 1493.046277308539, "at": "2024-05-25T21:10:52.903492"} +{"lr": 1.886424707612324e-05, "step": 320, "loss": 1.7327886819839478, "percent_done": 64.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137971878051758, "wps": 5560.007250718914, "avg_wps": 3975.968507761581, "eta_in_seconds": 1483.4725145548582, "at": "2024-05-25T21:10:58.798079"} +{"lr": 1.86802523866639e-05, "step": 321, "loss": 1.5958361625671387, "percent_done": 64.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138948917388916, "wps": 5567.4000591419235, "avg_wps": 3979.5122354855016, "eta_in_seconds": 1473.9173177298726, "at": "2024-05-25T21:11:04.684867"} +{"lr": 1.8496752864885245e-05, "step": 322, "loss": 1.3502188920974731, "percent_done": 64.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13797616958618, "wps": 5575.761992340734, "avg_wps": 3983.0534879014444, "eta_in_seconds": 1464.3800334885993, "at": "2024-05-25T21:11:10.562826"} +{"lr": 1.831375653765083e-05, "step": 323, "loss": 0.885614812374115, "percent_done": 64.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13803195953369, "wps": 5562.932385166707, "avg_wps": 3986.558710951784, "eta_in_seconds": 1454.8728415980795, "at": "2024-05-25T21:11:16.454339"} +{"lr": 1.813127140981282e-05, "step": 324, "loss": 1.124575138092041, "percent_done": 64.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138216495513916, "wps": 5569.705655267851, "avg_wps": 3990.0591563439916, "eta_in_seconds": 1445.3840843012304, "at": "2024-05-25T21:11:22.338698"} +{"lr": 1.794930546386188e-05, "step": 325, "loss": 1.4259119033813477, "percent_done": 65.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5563.349644169997, "avg_wps": 3993.534090635499, "eta_in_seconds": 1435.9211339767162, "at": "2024-05-25T21:11:28.229803"} +{"lr": 1.7767866659577976e-05, "step": 326, "loss": 1.2779805660247803, "percent_done": 65.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5574.191680163554, "avg_wps": 3997.010841957069, "eta_in_seconds": 1426.47398904935, "at": "2024-05-25T21:11:34.109450"} +{"lr": 1.758696293368218e-05, "step": 327, "loss": 1.1339479684829712, "percent_done": 65.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5569.125410170993, "avg_wps": 4000.464345021645, "eta_in_seconds": 1417.0514997976636, "at": "2024-05-25T21:11:39.994354"} +{"lr": 1.740660219948953e-05, "step": 328, "loss": 1.6315221786499023, "percent_done": 65.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137459754943848, "wps": 5572.366942184144, "avg_wps": 4003.90781380591, "eta_in_seconds": 1407.648792653549, "at": "2024-05-25T21:11:45.875938"} +{"lr": 1.7226792346562806e-05, "step": 329, "loss": 1.3715509176254272, "percent_done": 65.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5562.6392379190975, "avg_wps": 4007.3209107239413, "eta_in_seconds": 1398.2728423383821, "at": "2024-05-25T21:11:51.767731"} +{"lr": 1.7047541240367497e-05, "step": 330, "loss": 1.8491694927215576, "percent_done": 66.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138216018676758, "wps": 5560.601345421692, "avg_wps": 4010.7158817271184, "eta_in_seconds": 1388.919126727364, "at": "2024-05-25T21:11:57.661705"} +{"lr": 1.6868856721927658e-05, "step": 331, "loss": 1.5057955980300903, "percent_done": 66.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138139724731445, "wps": 5562.71353498971, "avg_wps": 4014.0993685555027, "eta_in_seconds": 1379.5851800232854, "at": "2024-05-25T21:12:03.553464"} +{"lr": 1.669074660748301e-05, "step": 332, "loss": 1.800534725189209, "percent_done": 66.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138704776763916, "wps": 5559.316586843242, "avg_wps": 4017.462794826868, "eta_in_seconds": 1370.2737974546042, "at": "2024-05-25T21:12:09.448785"} +{"lr": 1.6513218688146936e-05, "step": 333, "loss": 1.8996511697769165, "percent_done": 66.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138688564300537, "wps": 5559.858803106684, "avg_wps": 4020.8124624380075, "eta_in_seconds": 1360.9826499298886, "at": "2024-05-25T21:12:15.343563"} +{"lr": 1.6336280729565724e-05, "step": 334, "loss": 1.7788630723953247, "percent_done": 66.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5572.8134111846375, "avg_wps": 4024.1678841011308, "eta_in_seconds": 1351.705037329725, "at": "2024-05-25T21:12:21.224616"} +{"lr": 1.6159940471578926e-05, "step": 335, "loss": 1.4005411863327026, "percent_done": 67.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138567447662354, "wps": 5567.801071777459, "avg_wps": 4027.501006388032, "eta_in_seconds": 1342.4503163188251, "at": "2024-05-25T21:12:27.110976"} +{"lr": 1.598420562788065e-05, "step": 336, "loss": 1.6571120023727417, "percent_done": 67.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5561.187916333589, "avg_wps": 4030.8094377559264, "eta_in_seconds": 1333.2190675309726, "at": "2024-05-25T21:12:33.004338"} +{"lr": 1.5809083885682293e-05, "step": 337, "loss": 1.3300546407699585, "percent_done": 67.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138704776763916, "wps": 5568.743611211866, "avg_wps": 4034.1154080095835, "eta_in_seconds": 1324.0037678137023, "at": "2024-05-25T21:12:38.889624"} +{"lr": 1.5634582905376138e-05, "step": 338, "loss": 1.3534265756607056, "percent_done": 67.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137399196624756, "wps": 5577.653465754372, "avg_wps": 4037.421029734246, "eta_in_seconds": 1314.8036731629682, "at": "2024-05-25T21:12:44.765692"} +{"lr": 1.546071032020041e-05, "step": 339, "loss": 1.702944040298462, "percent_done": 67.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5550.139942691461, "avg_wps": 4040.669717386271, "eta_in_seconds": 1305.6370277679073, "at": "2024-05-25T21:12:50.670797"} +{"lr": 1.5287473735905225e-05, "step": 340, "loss": 1.8083207607269287, "percent_done": 68.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5571.423175918621, "avg_wps": 4043.9375863220316, "eta_in_seconds": 1296.4789609348074, "at": "2024-05-25T21:12:56.553344"} +{"lr": 1.5114880730419973e-05, "step": 341, "loss": 1.3005975484848022, "percent_done": 68.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137727737426758, "wps": 5570.202491695699, "avg_wps": 4047.189643037744, "eta_in_seconds": 1287.3407128234762, "at": "2024-05-25T21:13:02.437153"} +{"lr": 1.4942938853521888e-05, "step": 342, "loss": 1.4668766260147095, "percent_done": 68.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138960361480713, "wps": 5559.475125244877, "avg_wps": 4050.4112533482034, "eta_in_seconds": 1278.226746906314, "at": "2024-05-25T21:13:08.332314"} +{"lr": 1.4771655626505637e-05, "step": 343, "loss": 1.0367624759674072, "percent_done": 68.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5563.010968289827, "avg_wps": 4053.6246438786393, "eta_in_seconds": 1269.1298410593595, "at": "2024-05-25T21:13:14.223708"} +{"lr": 1.4601038541854481e-05, "step": 344, "loss": 1.473166823387146, "percent_done": 68.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138344287872314, "wps": 5566.3231592720895, "avg_wps": 4056.829527624119, "eta_in_seconds": 1260.0499885913937, "at": "2024-05-25T21:13:20.111634"} +{"lr": 1.4431095062912406e-05, "step": 345, "loss": 1.181746482849121, "percent_done": 69.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5559.996229335895, "avg_wps": 4060.0110924356927, "eta_in_seconds": 1250.991656023523, "at": "2024-05-25T21:13:26.006265"} +{"lr": 1.426183262355772e-05, "step": 346, "loss": 1.688283920288086, "percent_done": 69.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138124465942383, "wps": 5569.1184145655925, "avg_wps": 4063.193274739023, "eta_in_seconds": 1241.9473204419792, "at": "2024-05-25T21:13:31.891219"} +{"lr": 1.4093258627877864e-05, "step": 347, "loss": 1.3797972202301025, "percent_done": 69.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5561.368164930783, "avg_wps": 4066.3501408594034, "eta_in_seconds": 1232.9248161941166, "at": "2024-05-25T21:13:37.784393"} +{"lr": 1.392538044984549e-05, "step": 348, "loss": 1.5088579654693604, "percent_done": 69.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137804985046387, "wps": 5571.398106545287, "avg_wps": 4069.509135816682, "eta_in_seconds": 1223.9156698687323, "at": "2024-05-25T21:13:43.666913"} +{"lr": 1.3758205432995999e-05, "step": 349, "loss": 1.319239616394043, "percent_done": 69.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5568.38848589162, "avg_wps": 4072.6502870189356, "eta_in_seconds": 1214.9258225708772, "at": "2024-05-25T21:13:49.552700"} +{"lr": 1.3591740890106174e-05, "step": 350, "loss": 1.7499316930770874, "percent_done": 70.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137712955474854, "wps": 1791.738106384087, "avg_wps": 4057.890966525679, "eta_in_seconds": 1211.269607918603, "at": "2024-05-25T21:14:07.842181"} +{"lr": 1.342599410287438e-05, "step": 351, "loss": 1.286567211151123, "percent_done": 70.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139437198638916, "wps": 5605.818376056611, "avg_wps": 4061.085788147314, "eta_in_seconds": 1202.2479343455063, "at": "2024-05-25T21:14:13.688634"} +{"lr": 1.3260972321602061e-05, "step": 352, "loss": 1.8038522005081177, "percent_done": 70.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13823890686035, "wps": 5596.7771322675835, "avg_wps": 4064.2539261683837, "eta_in_seconds": 1193.2482783062892, "at": "2024-05-25T21:14:19.544476"} +{"lr": 1.3096682764876501e-05, "step": 353, "loss": 0.9818081855773926, "percent_done": 70.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5588.417991638859, "avg_wps": 4067.3964938553117, "eta_in_seconds": 1184.2700870881338, "at": "2024-05-25T21:14:25.409216"} +{"lr": 1.2933132619255162e-05, "step": 354, "loss": 1.3785500526428223, "percent_done": 70.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139925479888916, "wps": 5553.554405811622, "avg_wps": 4070.473551287197, "eta_in_seconds": 1175.3246740756063, "at": "2024-05-25T21:14:31.310677"} +{"lr": 1.2770329038951215e-05, "step": 355, "loss": 1.7617279291152954, "percent_done": 71.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137887477874756, "wps": 5575.839581094822, "avg_wps": 4073.5715328943215, "eta_in_seconds": 1166.3867840867647, "at": "2024-05-25T21:14:37.188446"} +{"lr": 1.2608279145520686e-05, "step": 356, "loss": 1.5587466955184937, "percent_done": 71.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13774824142456, "wps": 5572.641006021815, "avg_wps": 4076.6519841013414, "eta_in_seconds": 1157.4674557460828, "at": "2024-05-25T21:14:43.069790"} +{"lr": 1.2446990027550896e-05, "step": 357, "loss": 1.0616648197174072, "percent_done": 71.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137519359588623, "wps": 5575.287684722869, "avg_wps": 4079.723772779428, "eta_in_seconds": 1148.564035453716, "at": "2024-05-25T21:14:48.948205"} +{"lr": 1.2286468740350344e-05, "step": 358, "loss": 0.8199485540390015, "percent_done": 71.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138948917388916, "wps": 5573.732106080966, "avg_wps": 4082.7806637661956, "eta_in_seconds": 1139.678171128534, "at": "2024-05-25T21:14:54.828484"} +{"lr": 1.2126722305640172e-05, "step": 359, "loss": 1.5771381855010986, "percent_done": 71.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460159301758, "wps": 5571.851648644565, "avg_wps": 4085.8222552088314, "eta_in_seconds": 1130.8098373858045, "at": "2024-05-25T21:15:00.710718"} +{"lr": 1.1967757711246922e-05, "step": 360, "loss": 1.397983193397522, "percent_done": 72.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138760566711426, "wps": 5539.569793024716, "avg_wps": 4088.802875312462, "eta_in_seconds": 1121.9714277982712, "at": "2024-05-25T21:15:06.627049"} +{"lr": 1.1809581910796943e-05, "step": 361, "loss": 1.665077567100525, "percent_done": 72.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138415336608887, "wps": 5554.388419432263, "avg_wps": 4091.793634505631, "eta_in_seconds": 1113.1431364451748, "at": "2024-05-25T21:15:12.527825"} +{"lr": 1.1652201823412147e-05, "step": 362, "loss": 1.300383448600769, "percent_done": 72.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.1383113861084, "wps": 5569.199203595208, "avg_wps": 4094.7943892983385, "eta_in_seconds": 1104.3250454328336, "at": "2024-05-25T21:15:18.412714"} +{"lr": 1.1495624333407409e-05, "step": 363, "loss": 1.0224937200546265, "percent_done": 72.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139925003051758, "wps": 5519.438517829922, "avg_wps": 4097.708096352042, "eta_in_seconds": 1095.5431412980577, "at": "2024-05-25T21:15:24.350818"} +{"lr": 1.133985628998939e-05, "step": 364, "loss": 1.627020001411438, "percent_done": 72.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139437198638916, "wps": 5553.369726768816, "avg_wps": 4100.661047997364, "eta_in_seconds": 1086.7633164112385, "at": "2024-05-25T21:15:30.252613"} +{"lr": 1.1184904506956906e-05, "step": 365, "loss": 1.3622757196426392, "percent_done": 73.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139436721801758, "wps": 5561.598162004065, "avg_wps": 4103.614334557353, "eta_in_seconds": 1077.9960394297561, "at": "2024-05-25T21:15:36.145513"} +{"lr": 1.1030775762402946e-05, "step": 366, "loss": 1.3456637859344482, "percent_done": 73.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137465953826904, "wps": 5570.10654863333, "avg_wps": 4106.568359990713, "eta_in_seconds": 1069.241180246645, "at": "2024-05-25T21:15:42.029691"} +{"lr": 1.0877476798418077e-05, "step": 367, "loss": 1.7805505990982056, "percent_done": 73.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460159301758, "wps": 5560.863003309677, "avg_wps": 4109.496776107091, "eta_in_seconds": 1060.505516232197, "at": "2024-05-25T21:15:47.923524"} +{"lr": 1.0725014320795634e-05, "step": 368, "loss": 1.4283993244171143, "percent_done": 73.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13836431503296, "wps": 5569.532539544631, "avg_wps": 4112.426286587963, "eta_in_seconds": 1051.782013481078, "at": "2024-05-25T21:15:53.808029"} +{"lr": 1.0573394998738269e-05, "step": 369, "loss": 1.0807466506958008, "percent_done": 73.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139437198638916, "wps": 5566.758063020766, "avg_wps": 4115.339957493329, "eta_in_seconds": 1043.0749450440653, "at": "2024-05-25T21:15:59.695697"} +{"lr": 1.0422625464566322e-05, "step": 370, "loss": 1.4248853921890259, "percent_done": 74.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13740873336792, "wps": 5572.752853503117, "avg_wps": 4118.250834772516, "eta_in_seconds": 1034.3808988107216, "at": "2024-05-25T21:16:05.576811"} +{"lr": 1.0272712313427651e-05, "step": 371, "loss": 1.166329264640808, "percent_done": 74.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137394428253174, "wps": 5579.326516576336, "avg_wps": 4121.159786255952, "eta_in_seconds": 1025.6996135159002, "at": "2024-05-25T21:16:11.451218"} +{"lr": 1.0123662103009122e-05, "step": 372, "loss": 0.9444820880889893, "percent_done": 74.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5562.069467879027, "avg_wps": 4124.031753030664, "eta_in_seconds": 1017.039695903819, "at": "2024-05-25T21:16:17.343789"} +{"lr": 9.97548135324981e-06, "step": 373, "loss": 1.7269147634506226, "percent_done": 74.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137242317199707, "wps": 5569.69910962754, "avg_wps": 4126.903539380048, "eta_in_seconds": 1008.3918754798797, "at": "2024-05-25T21:16:23.228108"} +{"lr": 9.828176546055728e-06, "step": 374, "loss": 1.2174543142318726, "percent_done": 74.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13847589492798, "wps": 5567.1454528684935, "avg_wps": 4129.7601832915025, "eta_in_seconds": 999.7597479641756, "at": "2024-05-25T21:16:29.115301"} +{"lr": 9.681754125016368e-06, "step": 375, "loss": 1.3974727392196655, "percent_done": 75.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5562.523518556038, "avg_wps": 4132.598720348109, "eta_in_seconds": 991.1438968976338, "at": "2024-05-25T21:16:35.007253"} +{"lr": 9.536220495122747e-06, "step": 376, "loss": 1.7830662727355957, "percent_done": 75.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13734006881714, "wps": 5573.877226551567, "avg_wps": 4135.442688136249, "eta_in_seconds": 982.538583271047, "at": "2024-05-25T21:16:40.887389"} +{"lr": 9.391582022487311e-06, "step": 377, "loss": 1.379837989807129, "percent_done": 75.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138704299926758, "wps": 5543.890426978815, "avg_wps": 4138.231373501985, "eta_in_seconds": 973.958108241109, "at": "2024-05-25T21:16:46.799208"} +{"lr": 9.247845034065422e-06, "step": 378, "loss": 1.703586459159851, "percent_done": 75.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138415813446045, "wps": 5567.922875578582, "avg_wps": 4141.044357149158, "eta_in_seconds": 965.3835253173081, "at": "2024-05-25T21:16:52.685436"} +{"lr": 9.105015817378586e-06, "step": 379, "loss": 1.2611359357833862, "percent_done": 75.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137423515319824, "wps": 5576.128465500567, "avg_wps": 4143.858267567243, "eta_in_seconds": 956.8203698066419, "at": "2024-05-25T21:16:58.563228"} +{"lr": 8.963100620239454e-06, "step": 380, "loss": 1.1832594871520996, "percent_done": 76.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137856483459473, "wps": 5558.211117218648, "avg_wps": 4146.635005827124, "eta_in_seconds": 948.2773367982162, "at": "2024-05-25T21:17:04.459709"} +{"lr": 8.82210565047849e-06, "step": 381, "loss": 1.623869776725769, "percent_done": 76.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5561.887373189297, "avg_wps": 4149.406236513766, "eta_in_seconds": 939.7469849267344, "at": "2024-05-25T21:17:10.352481"} +{"lr": 8.682037075672413e-06, "step": 382, "loss": 1.3632287979125977, "percent_done": 76.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138704776763916, "wps": 5565.021334309865, "avg_wps": 4152.171205355702, "eta_in_seconds": 931.2294240210068, "at": "2024-05-25T21:17:16.241897"} +{"lr": 8.542901022874465e-06, "step": 383, "loss": 1.3607807159423828, "percent_done": 76.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5550.070463575346, "avg_wps": 4154.903575636029, "eta_in_seconds": 922.73043891593, "at": "2024-05-25T21:17:22.147079"} +{"lr": 8.404703578346311e-06, "step": 384, "loss": 1.650539755821228, "percent_done": 76.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139925003051758, "wps": 5558.409831018848, "avg_wps": 4157.637453946678, "eta_in_seconds": 914.2422931542, "at": "2024-05-25T21:17:28.043572"} +{"lr": 8.267450787291907e-06, "step": 385, "loss": 1.3313953876495361, "percent_done": 77.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139925479888916, "wps": 5566.828411536108, "avg_wps": 4160.372933957038, "eta_in_seconds": 905.7649542046832, "at": "2024-05-25T21:17:33.931003"} +{"lr": 8.13114865359295e-06, "step": 386, "loss": 1.2882438898086548, "percent_done": 77.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138752460479736, "wps": 5548.098878499625, "avg_wps": 4163.070586334242, "eta_in_seconds": 897.3069090546721, "at": "2024-05-25T21:17:39.838463"} +{"lr": 7.995803139546319e-06, "step": 387, "loss": 1.7669321298599243, "percent_done": 77.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137971878051758, "wps": 5572.439465935346, "avg_wps": 4165.793074789727, "eta_in_seconds": 888.8545190610319, "at": "2024-05-25T21:17:45.720001"} +{"lr": 7.861420165603275e-06, "step": 388, "loss": 1.8801156282424927, "percent_done": 77.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137239933013916, "wps": 5569.788267085214, "avg_wps": 4168.501239933507, "eta_in_seconds": 880.4161948764447, "at": "2024-05-25T21:17:51.604226"} +{"lr": 7.728005610110419e-06, "step": 389, "loss": 1.4096988439559937, "percent_done": 77.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5571.2199172304345, "avg_wps": 4171.20104121124, "eta_in_seconds": 871.990576350597, "at": "2024-05-25T21:17:57.487129"} +{"lr": 7.59556530905263e-06, "step": 390, "loss": 1.5848459005355835, "percent_done": 78.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137835025787354, "wps": 5560.799330206654, "avg_wps": 4173.875444670529, "eta_in_seconds": 863.5811125131754, "at": "2024-05-25T21:18:03.380850"} +{"lr": 7.464105055797707e-06, "step": 391, "loss": 1.462361454963684, "percent_done": 78.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13821315765381, "wps": 5575.103140477403, "avg_wps": 4176.5601572032265, "eta_in_seconds": 855.1803076126996, "at": "2024-05-25T21:18:09.259626"} +{"lr": 7.333630600843008e-06, "step": 392, "loss": 1.3138586282730103, "percent_done": 78.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137810230255127, "wps": 5577.294260918882, "avg_wps": 4179.237741510846, "eta_in_seconds": 846.7917402374501, "at": "2024-05-25T21:18:15.136079"} +{"lr": 7.204147651563878e-06, "step": 393, "loss": 1.7247304916381836, "percent_done": 78.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139925003051758, "wps": 5570.711383801347, "avg_wps": 4181.895680270274, "eta_in_seconds": 838.4178535446865, "at": "2024-05-25T21:18:21.019321"} +{"lr": 7.07566187196397e-06, "step": 394, "loss": 1.8703032732009888, "percent_done": 78.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139925479888916, "wps": 5558.353407443389, "avg_wps": 4184.525746860019, "eta_in_seconds": 830.060133482599, "at": "2024-05-25T21:18:26.915855"} +{"lr": 6.948178882427538e-06, "step": 395, "loss": 1.008700966835022, "percent_done": 79.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13745403289795, "wps": 5575.491014158058, "avg_wps": 4187.170326788489, "eta_in_seconds": 821.7100646676896, "at": "2024-05-25T21:18:32.794228"} +{"lr": 6.821704259473511e-06, "step": 396, "loss": 1.5449436902999878, "percent_done": 79.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139421939849854, "wps": 5557.028569506285, "avg_wps": 4189.778454604385, "eta_in_seconds": 813.3776133807019, "at": "2024-05-25T21:18:38.691946"} +{"lr": 6.696243535511637e-06, "step": 397, "loss": 1.630293846130371, "percent_done": 79.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13733673095703, "wps": 5569.892099620937, "avg_wps": 4192.395069217036, "eta_in_seconds": 805.0538998058521, "at": "2024-05-25T21:18:44.576263"} +{"lr": 6.571802198600406e-06, "step": 398, "loss": 1.6039057970046997, "percent_done": 79.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139925003051758, "wps": 5539.323083922311, "avg_wps": 4194.957972584161, "eta_in_seconds": 796.7507712457648, "at": "2024-05-25T21:18:50.492868"} +{"lr": 6.4483856922070286e-06, "step": 399, "loss": 1.7481942176818848, "percent_done": 79.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138357639312744, "wps": 5551.880177362594, "avg_wps": 4197.529171594472, "eta_in_seconds": 788.4562238176962, "at": "2024-05-25T21:18:56.396279"} +{"lr": 6.325999414969323e-06, "step": 400, "loss": 1.016953706741333, "percent_done": 80.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13891839981079, "wps": 5560.470638193474, "avg_wps": 4200.102917056915, "eta_in_seconds": 780.1713588237762, "at": "2024-05-25T21:19:02.290510"} +{"lr": 6.2046487204595115e-06, "step": 401, "loss": 1.5779600143432617, "percent_done": 80.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5651.918591848962, "avg_wps": 4202.795130143399, "eta_in_seconds": 771.8748831540867, "at": "2024-05-25T21:19:23.547649"} +{"lr": 6.084338916950114e-06, "step": 402, "loss": 1.1514184474945068, "percent_done": 80.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138722896575928, "wps": 5590.77855690672, "avg_wps": 4205.392252716004, "eta_in_seconds": 763.60629568527, "at": "2024-05-25T21:19:29.410196"} +{"lr": 5.965075267181666e-06, "step": 403, "loss": 1.0465856790542603, "percent_done": 80.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138948917388916, "wps": 5602.2206171603875, "avg_wps": 4207.995725738191, "eta_in_seconds": 755.346774845502, "at": "2024-05-25T21:19:35.260479"} +{"lr": 5.846862988132589e-06, "step": 404, "loss": 1.2216250896453857, "percent_done": 80.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13804864883423, "wps": 5592.157308778216, "avg_wps": 4210.575415600296, "eta_in_seconds": 747.1016878940092, "at": "2024-05-25T21:19:41.121473"} +{"lr": 5.7297072507909045e-06, "step": 405, "loss": 1.0939444303512573, "percent_done": 81.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13862133026123, "wps": 5565.891479111691, "avg_wps": 4213.108522244242, "eta_in_seconds": 738.8748672302859, "at": "2024-05-25T21:19:47.010033"} +{"lr": 5.613613179928103e-06, "step": 406, "loss": 1.8440186977386475, "percent_done": 81.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138704776763916, "wps": 5571.993282745541, "avg_wps": 4215.640789903421, "eta_in_seconds": 730.6580786904678, "at": "2024-05-25T21:19:52.891971"} +{"lr": 5.498585853874947e-06, "step": 407, "loss": 1.854995846748352, "percent_done": 81.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13826560974121, "wps": 5566.301742750904, "avg_wps": 4218.15561501231, "eta_in_seconds": 722.4541430274157, "at": "2024-05-25T21:19:58.780104"} +{"lr": 5.384630304299297e-06, "step": 408, "loss": 1.4698195457458496, "percent_done": 81.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138020992279053, "wps": 5575.626499956978, "avg_wps": 4220.674211061296, "eta_in_seconds": 714.2593456039242, "at": "2024-05-25T21:20:04.658247"} +{"lr": 5.271751515986073e-06, "step": 409, "loss": 1.3864424228668213, "percent_done": 81.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137486934661865, "wps": 5575.194280287401, "avg_wps": 4223.182872289802, "eta_in_seconds": 706.0759834875978, "at": "2024-05-25T21:20:10.536998"} +{"lr": 5.159954426619136e-06, "step": 410, "loss": 1.7188284397125244, "percent_done": 82.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137778759002686, "wps": 5573.151247774565, "avg_wps": 4225.679394605296, "eta_in_seconds": 697.9043426164766, "at": "2024-05-25T21:20:16.417896"} +{"lr": 5.049243926565364e-06, "step": 411, "loss": 1.463263988494873, "percent_done": 82.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13768196105957, "wps": 5564.682680177914, "avg_wps": 4228.154822599973, "eta_in_seconds": 689.7457927537951, "at": "2024-05-25T21:20:22.307576"} +{"lr": 4.939624858660665e-06, "step": 412, "loss": 1.6887528896331787, "percent_done": 82.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5568.185222975631, "avg_wps": 4230.626025461957, "eta_in_seconds": 681.5974710705211, "at": "2024-05-25T21:20:28.193724"} +{"lr": 4.831102017998196e-06, "step": 413, "loss": 1.1727441549301147, "percent_done": 82.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13826894760132, "wps": 5553.139736629514, "avg_wps": 4233.067019249099, "eta_in_seconds": 673.4634691670212, "at": "2024-05-25T21:20:34.095678"} +{"lr": 4.7236801517185786e-06, "step": 414, "loss": 1.978340983390808, "percent_done": 82.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5562.950623458758, "avg_wps": 4235.512780623792, "eta_in_seconds": 665.338093864745, "at": "2024-05-25T21:20:39.987353"} +{"lr": 4.617363958802224e-06, "step": 415, "loss": 1.2564210891723633, "percent_done": 83.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5558.878797965816, "avg_wps": 4237.943864126233, "eta_in_seconds": 657.2243732573038, "at": "2024-05-25T21:20:45.883353"} +{"lr": 4.512158089863847e-06, "step": 416, "loss": 1.4227871894836426, "percent_done": 83.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5564.845355195439, "avg_wps": 4240.374368753538, "eta_in_seconds": 649.1200447495166, "at": "2024-05-25T21:20:51.772895"} +{"lr": 4.408067146948968e-06, "step": 417, "loss": 1.4768786430358887, "percent_done": 83.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139437198638916, "wps": 5548.161141237663, "avg_wps": 4242.7726581129955, "eta_in_seconds": 641.0298687108129, "at": "2024-05-25T21:20:57.680299"} +{"lr": 4.305095683332627e-06, "step": 418, "loss": 1.1318224668502808, "percent_done": 83.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138216495513916, "wps": 5565.405327377419, "avg_wps": 4245.186244862107, "eta_in_seconds": 632.9465528755097, "at": "2024-05-25T21:21:03.569239"} +{"lr": 4.20324820332023e-06, "step": 419, "loss": 1.6629787683486938, "percent_done": 83.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137239933013916, "wps": 5556.090440452074, "avg_wps": 4247.5780676192, "eta_in_seconds": 624.8756250612491, "at": "2024-05-25T21:21:09.468185"} +{"lr": 4.102529162050497e-06, "step": 420, "loss": 1.2471615076065063, "percent_done": 84.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138096809387207, "wps": 5569.002876786291, "avg_wps": 4249.979124897588, "eta_in_seconds": 616.8124414171491, "at": "2024-05-25T21:21:15.353478"} +{"lr": 4.002942965300582e-06, "step": 421, "loss": 1.8307052850723267, "percent_done": 84.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137971878051758, "wps": 5565.72198124203, "avg_wps": 4252.366925997308, "eta_in_seconds": 608.760261061639, "at": "2024-05-25T21:21:21.242085"} +{"lr": 3.90449396929334e-06, "step": 422, "loss": 1.4666175842285156, "percent_done": 84.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5558.901731264854, "avg_wps": 4254.736619714039, "eta_in_seconds": 600.7196751397933, "at": "2024-05-25T21:21:27.138079"} +{"lr": 3.8071864805067762e-06, "step": 423, "loss": 1.4651637077331543, "percent_done": 84.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138704299926758, "wps": 5548.26036136631, "avg_wps": 4257.082950919814, "eta_in_seconds": 592.6912933314663, "at": "2024-05-25T21:21:33.045345"} +{"lr": 3.711024755485704e-06, "step": 424, "loss": 1.3158888816833496, "percent_done": 84.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13802671432495, "wps": 5566.186096384204, "avg_wps": 4259.445622546452, "eta_in_seconds": 584.6695135202049, "at": "2024-05-25T21:21:38.933623"} +{"lr": 3.6160130006554755e-06, "step": 425, "loss": 1.4103199243545532, "percent_done": 85.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13737154006958, "wps": 5572.690037597293, "avg_wps": 4261.808742138551, "eta_in_seconds": 576.656567363178, "at": "2024-05-25T21:21:44.815037"} +{"lr": 3.522155372138053e-06, "step": 426, "loss": 1.3419618606567383, "percent_done": 85.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5557.369213897184, "avg_wps": 4264.14225674588, "eta_in_seconds": 568.6564504652516, "at": "2024-05-25T21:21:50.712541"} +{"lr": 3.4294559755701608e-06, "step": 427, "loss": 1.2518714666366577, "percent_done": 85.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13725519180298, "wps": 5563.73453270832, "avg_wps": 4266.476156344868, "eta_in_seconds": 560.6650341740816, "at": "2024-05-25T21:21:56.626489"} +{"lr": 3.337918865923721e-06, "step": 428, "loss": 1.4638824462890625, "percent_done": 85.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13787078857422, "wps": 5570.055079364365, "avg_wps": 4268.810371768065, "eta_in_seconds": 552.6823153362096, "at": "2024-05-25T21:22:02.510689"} +{"lr": 3.2475480473284393e-06, "step": 429, "loss": 1.631824254989624, "percent_done": 85.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138704299926758, "wps": 5561.073382409856, "avg_wps": 4271.123912587601, "eta_in_seconds": 544.7109584302614, "at": "2024-05-25T21:22:08.404248"} +{"lr": 3.158347472896674e-06, "step": 430, "loss": 2.135599374771118, "percent_done": 86.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137957096099854, "wps": 5565.930474098261, "avg_wps": 4273.435848801319, "eta_in_seconds": 536.7484340834063, "at": "2024-05-25T21:22:14.292865"} +{"lr": 3.0703210445505373e-06, "step": 431, "loss": 1.734660029411316, "percent_done": 86.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13732147216797, "wps": 5559.907160170438, "avg_wps": 4275.731287502558, "eta_in_seconds": 528.7965608616717, "at": "2024-05-25T21:22:20.187632"} +{"lr": 2.9834726128511543e-06, "step": 432, "loss": 0.983702540397644, "percent_done": 86.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5558.675554251979, "avg_wps": 4278.016861093714, "eta_in_seconds": 520.8544221189287, "at": "2024-05-25T21:22:26.083883"} +{"lr": 2.897805976830286e-06, "step": 433, "loss": 1.4449166059494019, "percent_done": 86.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139925479888916, "wps": 5564.677948775421, "avg_wps": 4280.302516209535, "eta_in_seconds": 512.9207554105799, "at": "2024-05-25T21:22:31.973746"} +{"lr": 2.8133248838241186e-06, "step": 434, "loss": 1.7018533945083618, "percent_done": 86.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137308597564697, "wps": 5556.545761902869, "avg_wps": 4282.568950831009, "eta_in_seconds": 504.997823696532, "at": "2024-05-25T21:22:37.872092"} +{"lr": 2.7300330293093305e-06, "step": 435, "loss": 1.1753430366516113, "percent_done": 87.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.1391339302063, "wps": 5544.138884963688, "avg_wps": 4284.8103519104725, "eta_in_seconds": 497.0861776998674, "at": "2024-05-25T21:22:43.783775"} +{"lr": 2.6479340567414757e-06, "step": 436, "loss": 1.379823088645935, "percent_done": 87.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13751459121704, "wps": 5564.160021505416, "avg_wps": 4287.071160803931, "eta_in_seconds": 489.18059004337414, "at": "2024-05-25T21:22:49.674058"} +{"lr": 2.5670315573955692e-06, "step": 437, "loss": 1.2588801383972168, "percent_done": 87.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5557.120018088272, "avg_wps": 4289.3144078058, "eta_in_seconds": 481.285306631564, "at": "2024-05-25T21:22:55.571928"} +{"lr": 2.48732907020903e-06, "step": 438, "loss": 1.150813102722168, "percent_done": 87.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137971878051758, "wps": 5561.925861926001, "avg_wps": 4291.5562824970475, "eta_in_seconds": 473.3984285108575, "at": "2024-05-25T21:23:01.464694"} +{"lr": 2.4088300816268335e-06, "step": 439, "loss": 1.0771619081497192, "percent_done": 87.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5561.750303593997, "avg_wps": 4293.790034013631, "eta_in_seconds": 465.5206668621315, "at": "2024-05-25T21:23:07.357524"} +{"lr": 2.3315380254490547e-06, "step": 440, "loss": 1.968916893005371, "percent_done": 88.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137727737426758, "wps": 5578.234357355437, "avg_wps": 4296.038229069095, "eta_in_seconds": 457.64955877174026, "at": "2024-05-25T21:23:13.233078"} +{"lr": 2.2554562826806213e-06, "step": 441, "loss": 1.3567079305648804, "percent_done": 88.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13732671737671, "wps": 5563.585886001322, "avg_wps": 4298.258793970542, "eta_in_seconds": 449.7895758887267, "at": "2024-05-25T21:23:19.124048"} +{"lr": 2.1805881813834265e-06, "step": 442, "loss": 1.4823507070541382, "percent_done": 88.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137971878051758, "wps": 5564.4769842507585, "avg_wps": 4300.472796604738, "eta_in_seconds": 441.93838442612554, "at": "2024-05-25T21:23:25.014068"} +{"lr": 2.106936996530766e-06, "step": 443, "loss": 1.2738310098648071, "percent_done": 88.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137364387512207, "wps": 5559.844858435255, "avg_wps": 4302.672813305126, "eta_in_seconds": 434.096683862247, "at": "2024-05-25T21:23:30.909022"} +{"lr": 2.034505949864056e-06, "step": 444, "loss": 1.4706244468688965, "percent_done": 88.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137460231781006, "wps": 5565.386847624103, "avg_wps": 4304.872632496543, "eta_in_seconds": 426.2630178992813, "at": "2024-05-25T21:23:36.797977"} +{"lr": 1.9632982097519294e-06, "step": 445, "loss": 1.3760243654251099, "percent_done": 89.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139436721801758, "wps": 5540.460584607698, "avg_wps": 4307.031101379895, "eta_in_seconds": 418.44137123193633, "at": "2024-05-25T21:23:42.713584"} +{"lr": 1.8933168910516103e-06, "step": 446, "loss": 1.4198901653289795, "percent_done": 89.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138282299041748, "wps": 5550.43648118386, "avg_wps": 4309.195548345205, "eta_in_seconds": 410.626990617658, "at": "2024-05-25T21:23:48.618448"} +{"lr": 1.8245650549726923e-06, "step": 447, "loss": 1.4282867908477783, "percent_done": 89.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138704299926758, "wps": 5553.422907688349, "avg_wps": 4311.356501796952, "eta_in_seconds": 402.820782571831, "at": "2024-05-25T21:23:54.520302"} +{"lr": 1.757045708943213e-06, "step": 448, "loss": 0.9289335012435913, "percent_done": 89.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5568.881477019295, "avg_wps": 4313.530721994572, "eta_in_seconds": 395.0211809809719, "at": "2024-05-25T21:24:00.405671"} +{"lr": 1.6907618064780943e-06, "step": 449, "loss": 1.685412049293518, "percent_done": 89.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13728141784668, "wps": 5576.219186356725, "avg_wps": 4315.707238733798, "eta_in_seconds": 387.2292320946012, "at": "2024-05-25T21:24:06.283330"} +{"lr": 1.625716247049965e-06, "step": 450, "loss": 1.7856664657592773, "percent_done": 90.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138367652893066, "wps": 5570.314241311466, "avg_wps": 4317.868388668554, "eta_in_seconds": 379.44648898972406, "at": "2024-05-25T21:24:12.167280"} +{"lr": 1.5619118759623072e-06, "step": 451, "loss": 1.6154760122299194, "percent_done": 90.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5555.850118321428, "avg_wps": 4320.002765987443, "eta_in_seconds": 371.67383610065656, "at": "2024-05-25T21:24:18.066527"} +{"lr": 1.4993514842250177e-06, "step": 452, "loss": 1.2474405765533447, "percent_done": 90.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137239933013916, "wps": 5578.4374489397, "avg_wps": 4322.159916795523, "eta_in_seconds": 363.90694242663085, "at": "2024-05-25T21:24:23.941731"} +{"lr": 1.4380378084322957e-06, "step": 453, "loss": 1.203157663345337, "percent_done": 90.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138051986694336, "wps": 5573.7038514165115, "avg_wps": 4324.303400397619, "eta_in_seconds": 356.14892328285487, "at": "2024-05-25T21:24:29.822106"} +{"lr": 1.37797353064294e-06, "step": 454, "loss": 1.4027765989303589, "percent_done": 90.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138582229614258, "wps": 5538.621478521761, "avg_wps": 4326.3927006629865, "eta_in_seconds": 348.4029546760778, "at": "2024-05-25T21:24:35.739495"} +{"lr": 1.319161278263055e-06, "step": 455, "loss": 1.4540263414382935, "percent_done": 91.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5571.572919306316, "avg_wps": 4328.518793893766, "eta_in_seconds": 340.66156812814563, "at": "2024-05-25T21:24:41.622170"} +{"lr": 1.261603623931077e-06, "step": 456, "loss": 1.6735625267028809, "percent_done": 91.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137261390686035, "wps": 5571.412335080845, "avg_wps": 4330.637426305247, "eta_in_seconds": 332.92835628358944, "at": "2024-05-25T21:24:47.504883"} +{"lr": 1.205303085405276e-06, "step": 457, "loss": 1.2910887002944946, "percent_done": 91.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139925479888916, "wps": 5569.90857774884, "avg_wps": 4332.746857620684, "eta_in_seconds": 325.20339782180616, "at": "2024-05-25T21:24:53.389087"} +{"lr": 1.1502621254535857e-06, "step": 458, "loss": 1.7966179847717285, "percent_done": 91.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138704299926758, "wps": 5538.575053381325, "avg_wps": 4334.807448258997, "eta_in_seconds": 317.4895347549405, "at": "2024-05-25T21:24:59.306707"} +{"lr": 1.0964831517459112e-06, "step": 459, "loss": 1.6063262224197388, "percent_done": 91.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460159301758, "wps": 5561.969077984508, "avg_wps": 4336.892126972377, "eta_in_seconds": 309.78128131074845, "at": "2024-05-25T21:25:05.199216"} +{"lr": 1.0439685167487763e-06, "step": 460, "loss": 1.6829705238342285, "percent_done": 92.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13744878768921, "wps": 5568.108749427445, "avg_wps": 4338.977848687336, "eta_in_seconds": 302.0803621748219, "at": "2024-05-25T21:25:11.085460"} +{"lr": 9.927205176224375e-07, "step": 461, "loss": 1.3642950057983398, "percent_done": 92.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138948917388916, "wps": 5576.554494538736, "avg_wps": 4341.067634524745, "eta_in_seconds": 294.38656745091436, "at": "2024-05-25T21:25:16.962783"} +{"lr": 9.427413961204031e-07, "step": 462, "loss": 1.1950602531433105, "percent_done": 92.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5569.414727696743, "avg_wps": 4343.140988700631, "eta_in_seconds": 286.70126142336693, "at": "2024-05-25T21:25:22.847640"} +{"lr": 8.940333384913533e-07, "step": 463, "loss": 1.5413306951522827, "percent_done": 92.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5561.296829195024, "avg_wps": 4345.1966673382885, "eta_in_seconds": 279.02442462809915, "at": "2024-05-25T21:25:28.741059"} +{"lr": 8.465984753835264e-07, "step": 464, "loss": 1.2351683378219604, "percent_done": 92.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5562.738301120959, "avg_wps": 4347.247317418645, "eta_in_seconds": 271.3551619833913, "at": "2024-05-25T21:25:34.632892"} +{"lr": 8.004388817514974e-07, "step": 465, "loss": 1.2106558084487915, "percent_done": 93.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5571.0424167742185, "avg_wps": 4349.301972154689, "eta_in_seconds": 263.6928885008699, "at": "2024-05-25T21:25:40.516042"} +{"lr": 7.555565767654276e-07, "step": 466, "loss": 1.9838687181472778, "percent_done": 93.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13819694519043, "wps": 5568.859815163824, "avg_wps": 4351.346880781339, "eta_in_seconds": 256.03842454406833, "at": "2024-05-25T21:25:46.401458"} +{"lr": 7.119535237227388e-07, "step": 467, "loss": 1.2917249202728271, "percent_done": 93.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137376308441162, "wps": 5567.113205905527, "avg_wps": 4353.382656918926, "eta_in_seconds": 248.39167268730588, "at": "2024-05-25T21:25:52.288608"} +{"lr": 6.696316299622224e-07, "step": 468, "loss": 1.4344767332077026, "percent_done": 93.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137239456176758, "wps": 5567.146129382207, "avg_wps": 4355.411669779767, "eta_in_seconds": 240.75244305276462, "at": "2024-05-25T21:25:58.175916"} +{"lr": 6.285927467806198e-07, "step": 469, "loss": 1.5802178382873535, "percent_done": 93.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138532638549805, "wps": 5539.090014243195, "avg_wps": 4357.397076897143, "eta_in_seconds": 233.122660632835, "at": "2024-05-25T21:26:04.092821"} +{"lr": 5.888386693516242e-07, "step": 470, "loss": 1.9996533393859863, "percent_done": 94.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5566.057380640592, "avg_wps": 4359.411202534348, "eta_in_seconds": 225.49834239736518, "at": "2024-05-25T21:26:09.981239"} +{"lr": 5.503711366473705e-07, "step": 471, "loss": 1.6387524604797363, "percent_done": 94.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138704776763916, "wps": 1804.3390203441036, "avg_wps": 4346.343832029245, "eta_in_seconds": 218.63709746044913, "at": "2024-05-25T21:26:28.143126"} +{"lr": 5.131918313623563e-07, "step": 472, "loss": 1.6784415245056152, "percent_done": 94.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.1379714012146, "wps": 5620.4823596521865, "avg_wps": 4348.4323286472645, "eta_in_seconds": 210.99649957883156, "at": "2024-05-25T21:26:33.974391"} +{"lr": 4.773023798398375e-07, "step": 473, "loss": 1.5189155340194702, "percent_done": 94.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137430667877197, "wps": 5605.540124740532, "avg_wps": 4350.495012118223, "eta_in_seconds": 203.3644441691312, "at": "2024-05-25T21:26:39.821132"} +{"lr": 4.4270435200069295e-07, "step": 474, "loss": 1.469867467880249, "percent_done": 94.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.139662742614746, "wps": 5567.549586345821, "avg_wps": 4352.5022859621085, "eta_in_seconds": 195.74211431153213, "at": "2024-05-25T21:26:45.707941"} +{"lr": 4.0939926127473865e-07, "step": 475, "loss": 1.3805568218231201, "percent_done": 95.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460159301758, "wps": 5584.489655552117, "avg_wps": 4354.524699264875, "eta_in_seconds": 188.12615763513665, "at": "2024-05-25T21:26:51.576726"} +{"lr": 3.7738856453453507e-07, "step": 476, "loss": 0.8665902614593506, "percent_done": 95.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5561.550450675563, "avg_wps": 4356.511034379379, "eta_in_seconds": 180.51876692010575, "at": "2024-05-25T21:26:57.469641"} +{"lr": 3.4667366203166475e-07, "step": 477, "loss": 1.4999852180480957, "percent_done": 95.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5566.265222326482, "avg_wps": 4358.496907975745, "eta_in_seconds": 172.91832847715173, "at": "2024-05-25T21:27:03.357679"} +{"lr": 3.172558973354582e-07, "step": 478, "loss": 1.6573591232299805, "percent_done": 95.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138216495513916, "wps": 5575.226168616909, "avg_wps": 4360.487758424471, "eta_in_seconds": 165.32462420224147, "at": "2024-05-25T21:27:09.236146"} +{"lr": 2.8913655727425123e-07, "step": 479, "loss": 1.5721526145935059, "percent_done": 95.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137972354888916, "wps": 5571.705278383674, "avg_wps": 4362.4676012287655, "eta_in_seconds": 157.73824883104615, "at": "2024-05-25T21:27:15.118437"} +{"lr": 2.623168718790634e-07, "step": 480, "loss": 1.5395798683166504, "percent_done": 96.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137763023376465, "wps": 5564.080054378123, "avg_wps": 4364.431221320796, "eta_in_seconds": 150.1593144138654, "at": "2024-05-25T21:27:21.008760"} +{"lr": 2.3679801432982478e-07, "step": 481, "loss": 1.5175504684448242, "percent_done": 96.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138704776763916, "wps": 5576.811319909498, "avg_wps": 4366.404696900043, "eta_in_seconds": 142.58687483595216, "at": "2024-05-25T21:27:26.885566"} +{"lr": 2.1258110090402713e-07, "step": 482, "loss": 1.7560124397277832, "percent_done": 96.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138060569763184, "wps": 5561.689310921519, "avg_wps": 4368.352455982622, "eta_in_seconds": 135.02207203821524, "at": "2024-05-25T21:27:32.778486"} +{"lr": 1.896671909279231e-07, "step": 483, "loss": 1.5978459119796753, "percent_done": 96.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137287139892578, "wps": 5563.772821782952, "avg_wps": 4370.2965400334515, "eta_in_seconds": 127.46411940177775, "at": "2024-05-25T21:27:38.669097"} +{"lr": 1.6805728673016362e-07, "step": 484, "loss": 1.5269981622695923, "percent_done": 96.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13945245742798, "wps": 5542.253084655899, "avg_wps": 4372.2067472582685, "eta_in_seconds": 119.91381705102842, "at": "2024-05-25T21:27:44.582522"} +{"lr": 1.477523335979629e-07, "step": 485, "loss": 1.5226186513900757, "percent_done": 97.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137239933013916, "wps": 5566.414012241749, "avg_wps": 4374.141632922304, "eta_in_seconds": 112.36947525899436, "at": "2024-05-25T21:27:50.470456"} +{"lr": 1.2875321973575205e-07, "step": 486, "loss": 0.8783822059631348, "percent_done": 97.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138704299926758, "wps": 5542.8952528797845, "avg_wps": 4376.040223553465, "eta_in_seconds": 104.83267441894783, "at": "2024-05-25T21:27:56.383169"} +{"lr": 1.1106077622631656e-07, "step": 487, "loss": 1.2663761377334595, "percent_done": 97.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137971878051758, "wps": 5541.142996524906, "avg_wps": 4377.930410548485, "eta_in_seconds": 97.30259735824147, "at": "2024-05-25T21:28:02.297908"} +{"lr": 9.467577699445256e-08, "step": 488, "loss": 1.403084635734558, "percent_done": 97.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.137329578399658, "wps": 5568.279971878027, "avg_wps": 4379.849047363664, "eta_in_seconds": 89.77843659627634, "at": "2024-05-25T21:28:08.183774"} +{"lr": 7.959893877311043e-08, "step": 489, "loss": 1.6503396034240723, "percent_done": 97.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5559.639969795521, "avg_wps": 4381.750551053947, "eta_in_seconds": 82.26118666506497, "at": "2024-05-25T21:28:14.078708"} +{"lr": 6.58309210720302e-08, "step": 490, "loss": 1.7447947263717651, "percent_done": 98.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5561.398094980047, "avg_wps": 4383.648165133936, "eta_in_seconds": 74.750524598725, "at": "2024-05-25T21:28:19.971912"} +{"lr": 5.337232614891126e-08, "step": 491, "loss": 1.4788233041763306, "percent_done": 98.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138948917388916, "wps": 5567.388331857759, "avg_wps": 4385.5472622445095, "eta_in_seconds": 67.24633947943475, "at": "2024-05-25T21:28:25.858647"} +{"lr": 4.222369898305362e-08, "step": 492, "loss": 1.588571548461914, "percent_done": 98.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13914394378662, "wps": 5532.782042475214, "avg_wps": 4387.396320128183, "eta_in_seconds": 59.74933214885433, "at": "2024-05-25T21:28:31.782326"} +{"lr": 3.2385527251530405e-08, "step": 493, "loss": 1.4330182075500488, "percent_done": 98.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13776683807373, "wps": 5560.1446842868445, "avg_wps": 4389.2741858505815, "eta_in_seconds": 52.25829836272806, "at": "2024-05-25T21:28:37.676802"} +{"lr": 2.385824130784165e-08, "step": 494, "loss": 1.3957666158676147, "percent_done": 98.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138948440551758, "wps": 5571.342548197608, "avg_wps": 4391.1601570686025, "eta_in_seconds": 44.773588975914095, "at": "2024-05-25T21:28:43.559376"} +{"lr": 1.6642214163099443e-08, "step": 495, "loss": 1.4953104257583618, "percent_done": 99.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13848638534546, "wps": 5564.695522596666, "avg_wps": 4393.031760874679, "eta_in_seconds": 37.29542805931785, "at": "2024-05-25T21:28:49.449103"} +{"lr": 1.0737761469707708e-08, "step": 496, "loss": 1.8397181034088135, "percent_done": 99.2, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460636138916, "wps": 5564.202821757316, "avg_wps": 4394.896784699052, "eta_in_seconds": 29.823681060344942, "at": "2024-05-25T21:28:55.339191"} +{"lr": 6.145141507556636e-09, "step": 497, "loss": 1.531818151473999, "percent_done": 99.4, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138460159301758, "wps": 5555.7007697153795, "avg_wps": 4396.745180406347, "eta_in_seconds": 22.35835736810082, "at": "2024-05-25T21:29:01.238469"} +{"lr": 2.864555172718443e-09, "step": 498, "loss": 1.7617837190628052, "percent_done": 99.6, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.13817071914673, "wps": 5565.62303712498, "avg_wps": 4398.600165768605, "eta_in_seconds": 14.899285574993455, "at": "2024-05-25T21:29:07.127158"} +{"lr": 8.961459686677561e-10, "step": 499, "loss": 1.6539171934127808, "percent_done": 99.8, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138001441955566, "wps": 5559.066766663757, "avg_wps": 4400.441049743969, "eta_in_seconds": 7.446526298064268, "at": "2024-05-25T21:29:13.022698"} +{"lr": 2.4e-10, "step": 500, "loss": 1.4225248098373413, "percent_done": 100.0, "peak_allocated_mem": 46.97587060928345, "allocated_mem": 20.138556957244873, "wps": 5570.524207261232, "avg_wps": 4402.290443341627, "eta_in_seconds": 0.0, "at": "2024-05-25T21:29:18.906229"} diff --git a/runs2/tb/events.out.tfevents.1716668772.scw-tender-archimedes.33493.0.train b/runs2/tb/events.out.tfevents.1716668772.scw-tender-archimedes.33493.0.train new file mode 100644 index 0000000000000000000000000000000000000000..b7f6643d42e75c75df8b6a3d815d82df4822d59d --- /dev/null +++ b/runs2/tb/events.out.tfevents.1716668772.scw-tender-archimedes.33493.0.train @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fbce854ae8197e42691d26ec1ab2c6767bd2746d32044e2b95e6b4a6759e60bc +size 215572 diff --git a/runs2/tb/events.out.tfevents.1716668775.scw-tender-archimedes.33493.1.eval b/runs2/tb/events.out.tfevents.1716668775.scw-tender-archimedes.33493.1.eval new file mode 100644 index 0000000000000000000000000000000000000000..65bccd5ca2bfe91ea350755ce6924ebe5ef80de8 --- /dev/null +++ b/runs2/tb/events.out.tfevents.1716668775.scw-tender-archimedes.33493.1.eval @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1164fb3d7d039a38396d1336065181e327a7ccae5f6be995e582d4cae242cbd3 +size 88 diff --git a/runs2/wandb/debug-internal.log b/runs2/wandb/debug-internal.log new file mode 120000 index 0000000000000000000000000000000000000000..07c9978075e3066a3ecf931c84dc90bb62cd9146 --- /dev/null +++ b/runs2/wandb/debug-internal.log @@ -0,0 +1 @@ +run-20240525_202613-sapihyp4/logs/debug-internal.log \ No newline at end of file diff --git a/runs2/wandb/debug.log b/runs2/wandb/debug.log new file mode 120000 index 0000000000000000000000000000000000000000..d948b535cff6217bd1615049f1ccd2550c6ff6a5 --- /dev/null +++ b/runs2/wandb/debug.log @@ -0,0 +1 @@ +run-20240525_202613-sapihyp4/logs/debug.log \ No newline at end of file diff --git a/runs2/wandb/latest-run b/runs2/wandb/latest-run new file mode 120000 index 0000000000000000000000000000000000000000..52e23c3be1bf3f7d1dda36713c3fc7ceada6718a --- /dev/null +++ b/runs2/wandb/latest-run @@ -0,0 +1 @@ +run-20240525_202613-sapihyp4 \ No newline at end of file diff --git a/runs2/wandb/run-20240525_202613-sapihyp4/files/conda-environment.yaml b/runs2/wandb/run-20240525_202613-sapihyp4/files/conda-environment.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b872d6a32156b541e625a9e137de272c9701a8f3 --- /dev/null +++ b/runs2/wandb/run-20240525_202613-sapihyp4/files/conda-environment.yaml @@ -0,0 +1,92 @@ +name: chemistralpy310 +channels: + - defaults +dependencies: + - _libgcc_mutex=0.1=main + - _openmp_mutex=5.1=1_gnu + - bzip2=1.0.8=h5eee18b_6 + - ca-certificates=2024.3.11=h06a4308_0 + - ld_impl_linux-64=2.38=h1181459_1 + - libffi=3.4.4=h6a678d5_1 + - libgcc-ng=11.2.0=h1234567_1 + - libgomp=11.2.0=h1234567_1 + - libstdcxx-ng=11.2.0=h1234567_1 + - libuuid=1.41.5=h5eee18b_0 + - ncurses=6.4=h6a678d5_0 + - openssl=3.0.13=h7f8727e_2 + - pip=24.0=py310h06a4308_0 + - python=3.10.14=h955ad1f_1 + - readline=8.2=h5eee18b_0 + - setuptools=69.5.1=py310h06a4308_0 + - sqlite=3.45.3=h5eee18b_0 + - tk=8.6.14=h39e8969_0 + - tzdata=2024a=h04d1e81_0 + - wheel=0.43.0=py310h06a4308_0 + - xz=5.4.6=h5eee18b_1 + - zlib=1.2.13=h5eee18b_1 + - pip: + - absl-py==2.1.0 + - annotated-types==0.7.0 + - attrs==23.2.0 + - certifi==2024.2.2 + - charset-normalizer==3.3.2 + - click==8.1.7 + - docker-pycreds==0.4.0 + - docstring-parser==0.16 + - filelock==3.14.0 + - fire==0.6.0 + - fsspec==2024.5.0 + - gitdb==4.0.11 + - gitpython==3.1.43 + - grpcio==1.64.0 + - idna==3.7 + - jinja2==3.1.4 + - jsonschema==4.21.1 + - jsonschema-specifications==2023.12.1 + - markdown==3.6 + - markupsafe==2.1.5 + - mistral-common==1.1.0 + - mpmath==1.3.0 + - networkx==3.3 + - numpy==1.26.4 + - nvidia-cublas-cu12==12.1.3.1 + - nvidia-cuda-cupti-cu12==12.1.105 + - nvidia-cuda-nvrtc-cu12==12.1.105 + - nvidia-cuda-runtime-cu12==12.1.105 + - nvidia-cudnn-cu12==8.9.2.26 + - nvidia-cufft-cu12==11.0.2.54 + - nvidia-curand-cu12==10.3.2.106 + - nvidia-cusolver-cu12==11.4.5.107 + - nvidia-cusparse-cu12==12.1.0.106 + - nvidia-nccl-cu12==2.19.3 + - nvidia-nvjitlink-cu12==12.5.40 + - nvidia-nvtx-cu12==12.1.105 + - platformdirs==4.2.2 + - protobuf==4.25.3 + - psutil==5.9.8 + - pydantic==2.6.1 + - pydantic-core==2.16.2 + - pyyaml==6.0.1 + - referencing==0.35.1 + - requests==2.32.2 + - rpds-py==0.18.1 + - safetensors==0.4.3 + - sentencepiece==0.1.99 + - sentry-sdk==2.3.1 + - setproctitle==1.3.3 + - simple-parsing==0.1.5 + - six==1.16.0 + - smmap==5.0.1 + - sympy==1.12 + - tensorboard==2.16.2 + - tensorboard-data-server==0.7.2 + - termcolor==2.4.0 + - torch==2.2.0 + - tqdm==4.66.4 + - triton==2.2.0 + - typing-extensions==4.12.0 + - urllib3==2.2.1 + - wandb==0.17.0 + - werkzeug==3.0.3 + - xformers==0.0.24 +prefix: /root/miniconda/envs/chemistralpy310 diff --git a/runs2/wandb/run-20240525_202613-sapihyp4/files/config.yaml b/runs2/wandb/run-20240525_202613-sapihyp4/files/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..11621f30dcf50cbcd79b16e48e3f6df4d69a60f7 --- /dev/null +++ b/runs2/wandb/run-20240525_202613-sapihyp4/files/config.yaml @@ -0,0 +1,115 @@ +wandb_version: 1 + +data: + desc: null + value: + data: '' + shuffle: false + instruct_data: /root/data/mol_instructions_train.jsonl + eval_instruct_data: '' + instruct: + shuffle: true + dynamic_chunk_fn_call: true +model_id_or_path: + desc: null + value: /root/mistral_models/7B-v0.3 +run_dir: + desc: null + value: /root/mistral-finetune/runs2 +optim: + desc: null + value: + lr: 6.0e-05 + weight_decay: 0.1 + pct_start: 0.05 +seed: + desc: null + value: 0 +num_microbatches: + desc: null + value: 1 +seq_len: + desc: null + value: 32768 +batch_size: + desc: null + value: 1 +max_norm: + desc: null + value: 1.0 +max_steps: + desc: null + value: 500 +log_freq: + desc: null + value: 1 +ckpt_freq: + desc: null + value: 100 +ckpt_only_lora: + desc: null + value: false +no_ckpt: + desc: null + value: false +num_ckpt_keep: + desc: null + value: 3 +eval_freq: + desc: null + value: 100 +no_eval: + desc: null + value: true +checkpoint: + desc: null + value: true +world_size: + desc: null + value: 1 +wandb: + desc: null + value: + project: CHEMISTral7b-ft + offline: false + key: aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df + run_name: run1 +mlflow: + desc: null + value: + tracking_uri: null + experiment_name: null +lora: + desc: null + value: + enable: true + rank: 64 + dropout: 0.0 + scaling: 2.0 +_wandb: + desc: null + value: + python_version: 3.10.14 + cli_version: 0.17.0 + framework: torch + is_jupyter_run: false + is_kaggle_kernel: false + start_time: 1716668773 + t: + 1: + - 1 + - 55 + 2: + - 1 + - 55 + 3: + - 2 + - 13 + - 16 + - 23 + - 61 + 4: 3.10.14 + 5: 0.17.0 + 8: + - 5 + 13: linux-x86_64 diff --git a/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log b/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log new file mode 100644 index 0000000000000000000000000000000000000000..b0bc4978f6d4a7bbe3f344d4fbc4b7bef60fd6a7 --- /dev/null +++ b/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log @@ -0,0 +1,537 @@ + +wandb: WARNING Calling wandb.login() after wandb.init() has no effect. +2024-05-25 20:26:15 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Reloading model from /root/mistral_models/7B-v0.3/consolidated.safetensors ... +2024-05-25 20:26:15 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Converting model to dtype torch.bfloat16 ... +2024-05-25 20:26:15 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Loaded model on cpu! +2024-05-25 20:26:15 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Initializing lora layers ... +2024-05-25 20:26:15 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Finished initialization! +2024-05-25 20:26:15 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Sharding model over 1 GPUs ... +2024-05-25 20:26:17 (UTC) - 0:00:06 - finetune.wrapped_model - INFO - Model sharded! +2024-05-25 20:26:17 (UTC) - 0:00:06 - finetune.wrapped_model - INFO - 167,772,160 out of 7,415,795,712 parameter are finetuned (2.26%). +2024-05-25 20:26:17 (UTC) - 0:00:06 - dataset - INFO - Loading /root/data/mol_instructions_train.jsonl ... +2024-05-25 20:38:26 (UTC) - 0:12:15 - dataset - INFO - /root/data/mol_instructions_train.jsonl loaded and tokenized. +2024-05-25 20:38:26 (UTC) - 0:12:16 - dataset - INFO - Shuffling /root/data/mol_instructions_train.jsonl ... +2024-05-25 20:38:33 (UTC) - 0:12:22 - train - INFO - step: 000001 - done (%): 0.2 - loss: 2.053 - lr: 2.4e-06 - peak_alloc_mem (GB): 39.1 - alloc_mem (GB): 20.1 - words_per_second: 44.5 - avg_words_per_second: 44.5 - ETA: >2024-05-30 02:37:44 +2024-05-25 20:38:38 (UTC) - 0:12:28 - train - INFO - step: 000002 - done (%): 0.4 - loss: 2.260 - lr: 2.6e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5696.6 - avg_words_per_second: 88.4 - ETA: >2024-05-27 23:55:58 +2024-05-25 20:38:44 (UTC) - 0:12:33 - train - INFO - step: 000003 - done (%): 0.6 - loss: 2.244 - lr: 3.4e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5655.1 - avg_words_per_second: 131.5 - ETA: >2024-05-27 07:02:10 +2024-05-25 20:38:50 (UTC) - 0:12:39 - train - INFO - step: 000004 - done (%): 0.8 - loss: 2.142 - lr: 4.6e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5638.7 - avg_words_per_second: 174.0 - ETA: >2024-05-26 22:35:18 +2024-05-25 20:38:56 (UTC) - 0:12:45 - train - INFO - step: 000005 - done (%): 1.0 - loss: 2.038 - lr: 6.3e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5630.2 - avg_words_per_second: 215.9 - ETA: >2024-05-26 17:31:12 +2024-05-25 20:39:02 (UTC) - 0:12:51 - train - INFO - step: 000006 - done (%): 1.2 - loss: 2.301 - lr: 8.4e-06 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5614.1 - avg_words_per_second: 257.1 - ETA: >2024-05-26 14:08:29 +2024-05-25 20:39:07 (UTC) - 0:12:57 - train - INFO - step: 000007 - done (%): 1.4 - loss: 2.632 - lr: 1.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5602.8 - avg_words_per_second: 297.6 - ETA: >2024-05-26 11:43:42 +2024-05-25 20:39:13 (UTC) - 0:13:03 - train - INFO - step: 000008 - done (%): 1.6 - loss: 1.823 - lr: 1.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5600.1 - avg_words_per_second: 337.6 - ETA: >2024-05-26 09:55:07 +2024-05-25 20:39:19 (UTC) - 0:13:08 - train - INFO - step: 000009 - done (%): 1.8 - loss: 2.131 - lr: 1.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5586.5 - avg_words_per_second: 377.0 - ETA: >2024-05-26 08:30:41 +2024-05-25 20:39:25 (UTC) - 0:13:14 - train - INFO - step: 000010 - done (%): 2.0 - loss: 1.809 - lr: 2.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5580.1 - avg_words_per_second: 415.7 - ETA: >2024-05-26 07:23:08 +2024-05-25 20:39:31 (UTC) - 0:13:20 - train - INFO - step: 000011 - done (%): 2.2 - loss: 2.022 - lr: 2.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.9 - avg_words_per_second: 453.9 - ETA: >2024-05-26 06:27:53 +2024-05-25 20:39:37 (UTC) - 0:13:26 - train - INFO - step: 000012 - done (%): 2.4 - loss: 1.389 - lr: 2.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5557.1 - avg_words_per_second: 491.5 - ETA: >2024-05-26 05:41:51 +2024-05-25 20:39:43 (UTC) - 0:13:32 - train - INFO - step: 000013 - done (%): 2.6 - loss: 1.787 - lr: 3.1e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5569.6 - avg_words_per_second: 528.6 - ETA: >2024-05-26 05:02:53 +2024-05-25 20:39:49 (UTC) - 0:13:38 - train - INFO - step: 000014 - done (%): 2.8 - loss: 2.123 - lr: 3.5e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5572.5 - avg_words_per_second: 565.1 - ETA: >2024-05-26 04:29:29 +2024-05-25 20:39:54 (UTC) - 0:13:44 - train - INFO - step: 000015 - done (%): 3.0 - loss: 1.918 - lr: 3.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5557.7 - avg_words_per_second: 601.1 - ETA: >2024-05-26 04:00:33 +2024-05-25 20:40:00 (UTC) - 0:13:50 - train - INFO - step: 000016 - done (%): 3.2 - loss: 1.365 - lr: 4.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.0 - avg_words_per_second: 636.6 - ETA: >2024-05-26 03:35:14 +2024-05-25 20:40:06 (UTC) - 0:13:56 - train - INFO - step: 000017 - done (%): 3.4 - loss: 2.056 - lr: 4.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.5 - avg_words_per_second: 671.6 - ETA: >2024-05-26 03:12:53 +2024-05-25 20:40:12 (UTC) - 0:14:01 - train - INFO - step: 000018 - done (%): 3.6 - loss: 1.997 - lr: 4.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.6 - avg_words_per_second: 706.1 - ETA: >2024-05-26 02:53:02 +2024-05-25 20:40:18 (UTC) - 0:14:07 - train - INFO - step: 000019 - done (%): 3.8 - loss: 1.867 - lr: 5.2e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.1 - avg_words_per_second: 740.1 - ETA: >2024-05-26 02:35:16 +2024-05-25 20:40:24 (UTC) - 0:14:13 - train - INFO - step: 000020 - done (%): 4.0 - loss: 2.020 - lr: 5.4e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.9 - avg_words_per_second: 773.6 - ETA: >2024-05-26 02:19:16 +2024-05-25 20:40:30 (UTC) - 0:14:19 - train - INFO - step: 000021 - done (%): 4.2 - loss: 2.037 - lr: 5.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5560.8 - avg_words_per_second: 806.6 - ETA: >2024-05-26 02:04:48 +2024-05-25 20:40:36 (UTC) - 0:14:25 - train - INFO - step: 000022 - done (%): 4.4 - loss: 1.675 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5560.0 - avg_words_per_second: 839.3 - ETA: >2024-05-26 01:51:39 +2024-05-25 20:40:42 (UTC) - 0:14:31 - train - INFO - step: 000023 - done (%): 4.6 - loss: 1.681 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.9 - avg_words_per_second: 871.4 - ETA: >2024-05-26 01:39:38 +2024-05-25 20:40:48 (UTC) - 0:14:37 - train - INFO - step: 000024 - done (%): 4.8 - loss: 1.571 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5543.6 - avg_words_per_second: 903.1 - ETA: >2024-05-26 01:28:38 +2024-05-25 20:40:53 (UTC) - 0:14:43 - train - INFO - step: 000025 - done (%): 5.0 - loss: 1.837 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5562.6 - avg_words_per_second: 934.5 - ETA: >2024-05-26 01:18:30 +2024-05-25 20:40:59 (UTC) - 0:14:49 - train - INFO - step: 000026 - done (%): 5.2 - loss: 2.171 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5561.2 - avg_words_per_second: 965.3 - ETA: >2024-05-26 01:09:09 +2024-05-25 20:41:05 (UTC) - 0:14:55 - train - INFO - step: 000027 - done (%): 5.4 - loss: 2.037 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.8 - avg_words_per_second: 995.8 - ETA: >2024-05-26 01:00:30 +2024-05-25 20:41:11 (UTC) - 0:15:00 - train - INFO - step: 000028 - done (%): 5.6 - loss: 1.783 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5559.7 - avg_words_per_second: 1025.9 - ETA: >2024-05-26 00:52:27 +2024-05-25 20:41:17 (UTC) - 0:15:06 - train - INFO - step: 000029 - done (%): 5.8 - loss: 1.610 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.2 - avg_words_per_second: 1055.6 - ETA: >2024-05-26 00:44:58 +2024-05-25 20:41:23 (UTC) - 0:15:12 - train - INFO - step: 000030 - done (%): 6.0 - loss: 1.361 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.8 - avg_words_per_second: 1084.8 - ETA: >2024-05-26 00:37:59 +2024-05-25 20:41:29 (UTC) - 0:15:18 - train - INFO - step: 000031 - done (%): 6.2 - loss: 1.913 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5557.8 - avg_words_per_second: 1113.8 - ETA: >2024-05-26 00:31:27 +2024-05-25 20:41:35 (UTC) - 0:15:24 - train - INFO - step: 000032 - done (%): 6.4 - loss: 1.879 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.5 - avg_words_per_second: 1142.3 - ETA: >2024-05-26 00:25:20 +2024-05-25 20:41:41 (UTC) - 0:15:30 - train - INFO - step: 000033 - done (%): 6.6 - loss: 1.801 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.5 - avg_words_per_second: 1170.5 - ETA: >2024-05-26 00:19:35 +2024-05-25 20:41:47 (UTC) - 0:15:36 - train - INFO - step: 000034 - done (%): 6.8 - loss: 1.551 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5547.4 - avg_words_per_second: 1198.3 - ETA: >2024-05-26 00:14:10 +2024-05-25 20:41:52 (UTC) - 0:15:42 - train - INFO - step: 000035 - done (%): 7.0 - loss: 1.941 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.8 - avg_words_per_second: 1225.7 - ETA: >2024-05-26 00:09:03 +2024-05-25 20:41:58 (UTC) - 0:15:48 - train - INFO - step: 000036 - done (%): 7.2 - loss: 1.995 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.6 - avg_words_per_second: 1252.9 - ETA: >2024-05-26 00:04:14 +2024-05-25 20:42:04 (UTC) - 0:15:54 - train - INFO - step: 000037 - done (%): 7.4 - loss: 1.251 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.9 - avg_words_per_second: 1279.7 - ETA: >2024-05-25 23:59:40 +2024-05-25 20:42:10 (UTC) - 0:15:59 - train - INFO - step: 000038 - done (%): 7.6 - loss: 1.606 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.0 - avg_words_per_second: 1306.1 - ETA: >2024-05-25 23:55:21 +2024-05-25 20:42:16 (UTC) - 0:16:05 - train - INFO - step: 000039 - done (%): 7.8 - loss: 2.437 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5545.0 - avg_words_per_second: 1332.2 - ETA: >2024-05-25 23:51:15 +2024-05-25 20:42:22 (UTC) - 0:16:11 - train - INFO - step: 000040 - done (%): 8.0 - loss: 1.587 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5561.7 - avg_words_per_second: 1358.0 - ETA: >2024-05-25 23:47:21 +2024-05-25 20:42:28 (UTC) - 0:16:17 - train - INFO - step: 000041 - done (%): 8.2 - loss: 1.577 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5534.3 - avg_words_per_second: 1383.5 - ETA: >2024-05-25 23:43:39 +2024-05-25 20:42:34 (UTC) - 0:16:23 - train - INFO - step: 000042 - done (%): 8.4 - loss: 1.167 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5540.3 - avg_words_per_second: 1408.7 - ETA: >2024-05-25 23:40:08 +2024-05-25 20:42:40 (UTC) - 0:16:29 - train - INFO - step: 000043 - done (%): 8.6 - loss: 1.176 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5564.5 - avg_words_per_second: 1433.6 - ETA: >2024-05-25 23:36:46 +2024-05-25 20:42:46 (UTC) - 0:16:35 - train - INFO - step: 000044 - done (%): 8.8 - loss: 1.958 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5560.8 - avg_words_per_second: 1458.2 - ETA: >2024-05-25 23:33:33 +2024-05-25 20:42:52 (UTC) - 0:16:41 - train - INFO - step: 000045 - done (%): 9.0 - loss: 1.780 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5550.6 - avg_words_per_second: 1482.5 - ETA: >2024-05-25 23:30:29 +2024-05-25 20:42:57 (UTC) - 0:16:47 - train - INFO - step: 000046 - done (%): 9.2 - loss: 1.309 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5561.6 - avg_words_per_second: 1506.5 - ETA: >2024-05-25 23:27:33 +2024-05-25 20:43:03 (UTC) - 0:16:53 - train - INFO - step: 000047 - done (%): 9.4 - loss: 1.648 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.7 - avg_words_per_second: 1530.2 - ETA: >2024-05-25 23:24:44 +2024-05-25 20:43:09 (UTC) - 0:16:58 - train - INFO - step: 000048 - done (%): 9.6 - loss: 1.856 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.8 - avg_words_per_second: 1553.6 - ETA: >2024-05-25 23:22:02 +2024-05-25 20:43:15 (UTC) - 0:17:04 - train - INFO - step: 000049 - done (%): 9.8 - loss: 1.863 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.8 - avg_words_per_second: 1576.8 - ETA: >2024-05-25 23:19:27 +2024-05-25 20:43:21 (UTC) - 0:17:10 - train - INFO - step: 000050 - done (%): 10.0 - loss: 1.316 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5535.9 - avg_words_per_second: 1599.7 - ETA: >2024-05-25 23:16:59 +2024-05-25 20:43:27 (UTC) - 0:17:16 - train - INFO - step: 000051 - done (%): 10.2 - loss: 2.010 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.2 - avg_words_per_second: 1622.3 - ETA: >2024-05-25 23:14:36 +2024-05-25 20:43:33 (UTC) - 0:17:22 - train - INFO - step: 000052 - done (%): 10.4 - loss: 1.692 - lr: 6.0e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5550.0 - avg_words_per_second: 1644.7 - ETA: >2024-05-25 23:12:18 +2024-05-25 20:43:39 (UTC) - 0:17:28 - train - INFO - step: 000053 - done (%): 10.6 - loss: 1.171 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.8 - avg_words_per_second: 1666.9 - ETA: >2024-05-25 23:10:06 +2024-05-25 20:43:45 (UTC) - 0:17:34 - train - INFO - step: 000054 - done (%): 10.8 - loss: 2.077 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5531.2 - avg_words_per_second: 1688.7 - ETA: >2024-05-25 23:07:59 +2024-05-25 20:43:51 (UTC) - 0:17:40 - train - INFO - step: 000055 - done (%): 11.0 - loss: 1.371 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5561.3 - avg_words_per_second: 1710.4 - ETA: >2024-05-25 23:05:56 +2024-05-25 20:43:56 (UTC) - 0:17:46 - train - INFO - step: 000056 - done (%): 11.2 - loss: 1.468 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5536.1 - avg_words_per_second: 1731.7 - ETA: >2024-05-25 23:03:58 +2024-05-25 20:44:02 (UTC) - 0:17:52 - train - INFO - step: 000057 - done (%): 11.4 - loss: 1.323 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.4 - avg_words_per_second: 1752.9 - ETA: >2024-05-25 23:02:04 +2024-05-25 20:44:08 (UTC) - 0:17:58 - train - INFO - step: 000058 - done (%): 11.6 - loss: 2.137 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5537.1 - avg_words_per_second: 1773.8 - ETA: >2024-05-25 23:00:14 +2024-05-25 20:44:14 (UTC) - 0:18:03 - train - INFO - step: 000059 - done (%): 11.8 - loss: 1.428 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.0 - avg_words_per_second: 1794.5 - ETA: >2024-05-25 22:58:27 +2024-05-25 20:44:20 (UTC) - 0:18:09 - train - INFO - step: 000060 - done (%): 12.0 - loss: 2.142 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5549.8 - avg_words_per_second: 1815.0 - ETA: >2024-05-25 22:56:44 +2024-05-25 20:44:26 (UTC) - 0:18:15 - train - INFO - step: 000061 - done (%): 12.2 - loss: 1.729 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5545.2 - avg_words_per_second: 1835.2 - ETA: >2024-05-25 22:55:04 +2024-05-25 20:44:32 (UTC) - 0:18:21 - train - INFO - step: 000062 - done (%): 12.4 - loss: 1.741 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5535.9 - avg_words_per_second: 1855.2 - ETA: >2024-05-25 22:53:28 +2024-05-25 20:44:38 (UTC) - 0:18:27 - train - INFO - step: 000063 - done (%): 12.6 - loss: 1.561 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.6 - avg_words_per_second: 1875.0 - ETA: >2024-05-25 22:51:55 +2024-05-25 20:44:44 (UTC) - 0:18:33 - train - INFO - step: 000064 - done (%): 12.8 - loss: 1.670 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5548.1 - avg_words_per_second: 1894.6 - ETA: >2024-05-25 22:50:24 +2024-05-25 20:44:50 (UTC) - 0:18:39 - train - INFO - step: 000065 - done (%): 13.0 - loss: 1.533 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.5 - avg_words_per_second: 1914.0 - ETA: >2024-05-25 22:48:57 +2024-05-25 20:44:56 (UTC) - 0:18:45 - train - INFO - step: 000066 - done (%): 13.2 - loss: 1.560 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.7 - avg_words_per_second: 1933.2 - ETA: >2024-05-25 22:47:32 +2024-05-25 20:45:01 (UTC) - 0:18:51 - train - INFO - step: 000067 - done (%): 13.4 - loss: 1.934 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5541.4 - avg_words_per_second: 1952.2 - ETA: >2024-05-25 22:46:09 +2024-05-25 20:45:07 (UTC) - 0:18:57 - train - INFO - step: 000068 - done (%): 13.6 - loss: 2.118 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.8 - avg_words_per_second: 1971.0 - ETA: >2024-05-25 22:44:49 +2024-05-25 20:45:13 (UTC) - 0:19:03 - train - INFO - step: 000069 - done (%): 13.8 - loss: 1.724 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5544.0 - avg_words_per_second: 1989.6 - ETA: >2024-05-25 22:43:32 +2024-05-25 20:45:19 (UTC) - 0:19:08 - train - INFO - step: 000070 - done (%): 14.0 - loss: 1.542 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5554.9 - avg_words_per_second: 2008.0 - ETA: >2024-05-25 22:42:16 +2024-05-25 20:45:25 (UTC) - 0:19:14 - train - INFO - step: 000071 - done (%): 14.2 - loss: 1.959 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.5 - avg_words_per_second: 2026.2 - ETA: >2024-05-25 22:41:03 +2024-05-25 20:45:31 (UTC) - 0:19:20 - train - INFO - step: 000072 - done (%): 14.4 - loss: 1.435 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5545.5 - avg_words_per_second: 2044.2 - ETA: >2024-05-25 22:39:52 +2024-05-25 20:45:37 (UTC) - 0:19:26 - train - INFO - step: 000073 - done (%): 14.6 - loss: 1.589 - lr: 5.9e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5558.8 - avg_words_per_second: 2062.1 - ETA: >2024-05-25 22:38:42 +2024-05-25 20:45:43 (UTC) - 0:19:32 - train - INFO - step: 000074 - done (%): 14.8 - loss: 1.679 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5532.5 - avg_words_per_second: 2079.7 - ETA: >2024-05-25 22:37:35 +2024-05-25 20:45:49 (UTC) - 0:19:38 - train - INFO - step: 000075 - done (%): 15.0 - loss: 1.515 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5566.8 - avg_words_per_second: 2097.2 - ETA: >2024-05-25 22:36:29 +2024-05-25 20:45:55 (UTC) - 0:19:44 - train - INFO - step: 000076 - done (%): 15.2 - loss: 1.520 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5562.9 - avg_words_per_second: 2114.6 - ETA: >2024-05-25 22:35:25 +2024-05-25 20:46:00 (UTC) - 0:19:50 - train - INFO - step: 000077 - done (%): 15.4 - loss: 1.344 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5555.0 - avg_words_per_second: 2131.7 - ETA: >2024-05-25 22:34:23 +2024-05-25 20:46:06 (UTC) - 0:19:56 - train - INFO - step: 000078 - done (%): 15.6 - loss: 1.934 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.8 - avg_words_per_second: 2148.7 - ETA: >2024-05-25 22:33:22 +2024-05-25 20:46:12 (UTC) - 0:20:02 - train - INFO - step: 000079 - done (%): 15.8 - loss: 1.504 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5539.4 - avg_words_per_second: 2165.5 - ETA: >2024-05-25 22:32:23 +2024-05-25 20:46:18 (UTC) - 0:20:07 - train - INFO - step: 000080 - done (%): 16.0 - loss: 1.471 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5563.2 - avg_words_per_second: 2182.1 - ETA: >2024-05-25 22:31:25 +2024-05-25 20:46:24 (UTC) - 0:20:13 - train - INFO - step: 000081 - done (%): 16.2 - loss: 1.544 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.6 - avg_words_per_second: 2198.6 - ETA: >2024-05-25 22:30:29 +2024-05-25 20:46:30 (UTC) - 0:20:19 - train - INFO - step: 000082 - done (%): 16.4 - loss: 1.469 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5552.4 - avg_words_per_second: 2214.9 - ETA: >2024-05-25 22:29:34 +2024-05-25 20:46:36 (UTC) - 0:20:25 - train - INFO - step: 000083 - done (%): 16.6 - loss: 1.967 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5559.3 - avg_words_per_second: 2231.1 - ETA: >2024-05-25 22:28:40 +2024-05-25 20:46:42 (UTC) - 0:20:31 - train - INFO - step: 000084 - done (%): 16.8 - loss: 1.149 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5559.2 - avg_words_per_second: 2247.1 - ETA: >2024-05-25 22:27:48 +2024-05-25 20:46:48 (UTC) - 0:20:37 - train - INFO - step: 000085 - done (%): 17.0 - loss: 1.274 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5561.9 - avg_words_per_second: 2263.0 - ETA: >2024-05-25 22:26:57 +2024-05-25 20:46:54 (UTC) - 0:20:43 - train - INFO - step: 000086 - done (%): 17.2 - loss: 1.430 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5559.7 - avg_words_per_second: 2278.7 - ETA: >2024-05-25 22:26:07 +2024-05-25 20:46:59 (UTC) - 0:20:49 - train - INFO - step: 000087 - done (%): 17.4 - loss: 1.811 - lr: 5.8e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5559.9 - avg_words_per_second: 2294.2 - ETA: >2024-05-25 22:25:18 +2024-05-25 20:47:05 (UTC) - 0:20:55 - train - INFO - step: 000088 - done (%): 17.6 - loss: 1.972 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5559.7 - avg_words_per_second: 2309.7 - ETA: >2024-05-25 22:24:31 +2024-05-25 20:47:11 (UTC) - 0:21:01 - train - INFO - step: 000089 - done (%): 17.8 - loss: 1.752 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5556.5 - avg_words_per_second: 2324.9 - ETA: >2024-05-25 22:23:44 +2024-05-25 20:47:17 (UTC) - 0:21:06 - train - INFO - step: 000090 - done (%): 18.0 - loss: 1.221 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5546.0 - avg_words_per_second: 2340.0 - ETA: >2024-05-25 22:22:59 +2024-05-25 20:47:23 (UTC) - 0:21:12 - train - INFO - step: 000091 - done (%): 18.2 - loss: 1.323 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5564.8 - avg_words_per_second: 2355.0 - ETA: >2024-05-25 22:22:14 +2024-05-25 20:47:29 (UTC) - 0:21:18 - train - INFO - step: 000092 - done (%): 18.4 - loss: 1.351 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5525.3 - avg_words_per_second: 2369.8 - ETA: >2024-05-25 22:21:31 +2024-05-25 20:47:35 (UTC) - 0:21:24 - train - INFO - step: 000093 - done (%): 18.6 - loss: 1.337 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5563.4 - avg_words_per_second: 2384.5 - ETA: >2024-05-25 22:20:48 +2024-05-25 20:47:41 (UTC) - 0:21:30 - train - INFO - step: 000094 - done (%): 18.8 - loss: 1.274 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5532.0 - avg_words_per_second: 2399.0 - ETA: >2024-05-25 22:20:06 +2024-05-25 20:47:47 (UTC) - 0:21:36 - train - INFO - step: 000095 - done (%): 19.0 - loss: 1.345 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5541.5 - avg_words_per_second: 2413.4 - ETA: >2024-05-25 22:19:26 +2024-05-25 20:47:53 (UTC) - 0:21:42 - train - INFO - step: 000096 - done (%): 19.2 - loss: 1.932 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5553.0 - avg_words_per_second: 2427.7 - ETA: >2024-05-25 22:18:46 +2024-05-25 20:47:59 (UTC) - 0:21:48 - train - INFO - step: 000097 - done (%): 19.4 - loss: 1.125 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5561.7 - avg_words_per_second: 2441.9 - ETA: >2024-05-25 22:18:06 +2024-05-25 20:48:04 (UTC) - 0:21:54 - train - INFO - step: 000098 - done (%): 19.6 - loss: 1.698 - lr: 5.7e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5543.3 - avg_words_per_second: 2456.0 - ETA: >2024-05-25 22:17:28 +2024-05-25 20:48:10 (UTC) - 0:22:00 - train - INFO - step: 000099 - done (%): 19.8 - loss: 1.771 - lr: 5.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5545.0 - avg_words_per_second: 2469.9 - ETA: >2024-05-25 22:16:51 +2024-05-25 20:48:16 (UTC) - 0:22:06 - train - INFO - step: 000100 - done (%): 20.0 - loss: 1.166 - lr: 5.6e-05 - peak_alloc_mem (GB): 40.3 - alloc_mem (GB): 20.1 - words_per_second: 5563.1 - avg_words_per_second: 2483.7 - ETA: >2024-05-25 22:16:14 +2024-05-25 20:48:16 (UTC) - 0:22:06 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runs2/checkpoints/checkpoint_000100/consolidated using tmp name: tmp.consolidated +2024-05-25 20:48:31 (UTC) - 0:22:20 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runs2/checkpoints/checkpoint_000100/consolidated for step: 100 +2024-05-25 20:48:31 (UTC) - 0:22:20 - checkpointing - INFO - Done deleting checkpoints +2024-05-25 20:48:31 (UTC) - 0:22:20 - checkpointing - INFO - Done! +2024-05-25 20:48:37 (UTC) - 0:22:26 - train - INFO - step: 000101 - done (%): 20.2 - loss: 1.227 - lr: 5.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5650.6 - avg_words_per_second: 2497.5 - ETA: >2024-05-25 22:15:52 +2024-05-25 20:48:43 (UTC) - 0:22:32 - train - INFO - step: 000102 - done (%): 20.4 - loss: 1.571 - lr: 5.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5593.4 - avg_words_per_second: 2511.1 - ETA: >2024-05-25 22:15:16 +2024-05-25 20:48:49 (UTC) - 0:22:38 - train - INFO - step: 000103 - done (%): 20.6 - loss: 1.692 - lr: 5.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5603.0 - avg_words_per_second: 2524.7 - ETA: >2024-05-25 22:14:41 +2024-05-25 20:48:54 (UTC) - 0:22:44 - train - INFO - step: 000104 - done (%): 20.8 - loss: 1.910 - lr: 5.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5581.9 - avg_words_per_second: 2538.0 - ETA: >2024-05-25 22:14:07 +2024-05-25 20:49:00 (UTC) - 0:22:50 - train - INFO - step: 000105 - done (%): 21.0 - loss: 1.646 - lr: 5.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5584.2 - avg_words_per_second: 2551.3 - ETA: >2024-05-25 22:13:34 +2024-05-25 20:49:06 (UTC) - 0:22:55 - train - INFO - step: 000106 - done (%): 21.2 - loss: 1.226 - lr: 5.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5580.8 - avg_words_per_second: 2564.4 - ETA: >2024-05-25 22:13:01 +2024-05-25 20:49:22 (UTC) - 0:23:11 - train - INFO - step: 000107 - done (%): 21.4 - loss: 1.880 - lr: 5.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 2108.6 - avg_words_per_second: 2559.3 - ETA: >2024-05-25 22:13:14 +2024-05-25 20:49:28 (UTC) - 0:23:17 - train - INFO - step: 000108 - done (%): 21.6 - loss: 2.020 - lr: 5.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5599.2 - avg_words_per_second: 2572.2 - ETA: >2024-05-25 22:12:41 +2024-05-25 20:49:33 (UTC) - 0:23:23 - train - INFO - step: 000109 - done (%): 21.8 - loss: 1.454 - lr: 5.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5568.6 - avg_words_per_second: 2584.9 - ETA: >2024-05-25 22:12:10 +2024-05-25 20:49:39 (UTC) - 0:23:29 - train - INFO - step: 000110 - done (%): 22.0 - loss: 1.806 - lr: 5.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5575.1 - avg_words_per_second: 2597.6 - ETA: >2024-05-25 22:11:39 +2024-05-25 20:49:45 (UTC) - 0:23:34 - train - INFO - step: 000111 - done (%): 22.2 - loss: 1.591 - lr: 5.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5574.6 - avg_words_per_second: 2610.2 - ETA: >2024-05-25 22:11:09 +2024-05-25 20:49:51 (UTC) - 0:23:40 - train - INFO - step: 000112 - done (%): 22.4 - loss: 1.455 - lr: 5.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5580.2 - avg_words_per_second: 2622.6 - ETA: >2024-05-25 22:10:39 +2024-05-25 20:49:57 (UTC) - 0:23:46 - train - INFO - step: 000113 - done (%): 22.6 - loss: 1.928 - lr: 5.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.4 - avg_words_per_second: 2634.9 - ETA: >2024-05-25 22:10:10 +2024-05-25 20:50:03 (UTC) - 0:23:52 - train - INFO - step: 000114 - done (%): 22.8 - loss: 1.295 - lr: 5.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5562.7 - avg_words_per_second: 2647.2 - ETA: >2024-05-25 22:09:41 +2024-05-25 20:50:09 (UTC) - 0:23:58 - train - INFO - step: 000115 - done (%): 23.0 - loss: 1.959 - lr: 5.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5576.9 - avg_words_per_second: 2659.3 - ETA: >2024-05-25 22:09:13 +2024-05-25 20:50:15 (UTC) - 0:24:04 - train - INFO - step: 000116 - done (%): 23.2 - loss: 1.356 - lr: 5.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.9 - avg_words_per_second: 2671.3 - ETA: >2024-05-25 22:08:45 +2024-05-25 20:50:21 (UTC) - 0:24:10 - train - INFO - step: 000117 - done (%): 23.4 - loss: 1.458 - lr: 5.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5534.6 - avg_words_per_second: 2683.2 - ETA: >2024-05-25 22:08:18 +2024-05-25 20:50:26 (UTC) - 0:24:16 - train - INFO - step: 000118 - done (%): 23.6 - loss: 2.077 - lr: 5.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.7 - avg_words_per_second: 2695.0 - ETA: >2024-05-25 22:07:51 +2024-05-25 20:50:32 (UTC) - 0:24:22 - train - INFO - step: 000119 - done (%): 23.8 - loss: 1.453 - lr: 5.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.8 - avg_words_per_second: 2706.7 - ETA: >2024-05-25 22:07:25 +2024-05-25 20:50:38 (UTC) - 0:24:28 - train - INFO - step: 000120 - done (%): 24.0 - loss: 1.728 - lr: 5.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5554.9 - avg_words_per_second: 2718.3 - ETA: >2024-05-25 22:06:59 +2024-05-25 20:50:44 (UTC) - 0:24:33 - train - INFO - step: 000121 - done (%): 24.2 - loss: 1.377 - lr: 5.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5558.7 - avg_words_per_second: 2729.9 - ETA: >2024-05-25 22:06:34 +2024-05-25 20:50:50 (UTC) - 0:24:39 - train - INFO - step: 000122 - done (%): 24.4 - loss: 1.395 - lr: 5.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5544.8 - avg_words_per_second: 2741.3 - ETA: >2024-05-25 22:06:09 +2024-05-25 20:50:56 (UTC) - 0:24:45 - train - INFO - step: 000123 - done (%): 24.6 - loss: 1.624 - lr: 5.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.7 - avg_words_per_second: 2752.6 - ETA: >2024-05-25 22:05:44 +2024-05-25 20:51:02 (UTC) - 0:24:51 - train - INFO - step: 000124 - done (%): 24.8 - loss: 2.117 - lr: 5.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5557.8 - avg_words_per_second: 2763.9 - ETA: >2024-05-25 22:05:20 +2024-05-25 20:51:08 (UTC) - 0:24:57 - train - INFO - step: 000125 - done (%): 25.0 - loss: 1.731 - lr: 5.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5565.3 - avg_words_per_second: 2775.0 - ETA: >2024-05-25 22:04:56 +2024-05-25 20:51:14 (UTC) - 0:25:03 - train - INFO - step: 000126 - done (%): 25.2 - loss: 1.206 - lr: 5.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.3 - avg_words_per_second: 2786.1 - ETA: >2024-05-25 22:04:32 +2024-05-25 20:51:20 (UTC) - 0:25:09 - train - INFO - step: 000127 - done (%): 25.4 - loss: 1.650 - lr: 5.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5540.6 - avg_words_per_second: 2797.1 - ETA: >2024-05-25 22:04:09 +2024-05-25 20:51:25 (UTC) - 0:25:15 - train - INFO - step: 000128 - done (%): 25.6 - loss: 1.434 - lr: 5.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.2 - avg_words_per_second: 2808.0 - ETA: >2024-05-25 22:03:47 +2024-05-25 20:51:31 (UTC) - 0:25:21 - train - INFO - step: 000129 - done (%): 25.8 - loss: 0.974 - lr: 5.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5551.1 - avg_words_per_second: 2818.8 - ETA: >2024-05-25 22:03:24 +2024-05-25 20:51:37 (UTC) - 0:25:27 - train - INFO - step: 000130 - done (%): 26.0 - loss: 1.666 - lr: 5.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5553.7 - avg_words_per_second: 2829.5 - ETA: >2024-05-25 22:03:02 +2024-05-25 20:51:43 (UTC) - 0:25:32 - train - INFO - step: 000131 - done (%): 26.2 - loss: 1.338 - lr: 5.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5568.7 - avg_words_per_second: 2840.1 - ETA: >2024-05-25 22:02:41 +2024-05-25 20:51:49 (UTC) - 0:25:38 - train - INFO - step: 000132 - done (%): 26.4 - loss: 1.545 - lr: 5.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5558.9 - avg_words_per_second: 2850.7 - ETA: >2024-05-25 22:02:19 +2024-05-25 20:51:55 (UTC) - 0:25:44 - train - INFO - step: 000133 - done (%): 26.6 - loss: 1.560 - lr: 5.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5550.9 - avg_words_per_second: 2861.2 - ETA: >2024-05-25 22:01:58 +2024-05-25 20:52:01 (UTC) - 0:25:50 - train - INFO - step: 000134 - done (%): 26.8 - loss: 1.303 - lr: 5.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.9 - avg_words_per_second: 2871.6 - ETA: >2024-05-25 22:01:37 +2024-05-25 20:52:07 (UTC) - 0:25:56 - train - INFO - step: 000135 - done (%): 27.0 - loss: 1.656 - lr: 5.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.2 - avg_words_per_second: 2881.9 - ETA: >2024-05-25 22:01:17 +2024-05-25 20:52:13 (UTC) - 0:26:02 - train - INFO - step: 000136 - done (%): 27.2 - loss: 1.487 - lr: 5.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.7 - avg_words_per_second: 2892.1 - ETA: >2024-05-25 22:00:57 +2024-05-25 20:52:19 (UTC) - 0:26:08 - train - INFO - step: 000137 - done (%): 27.4 - loss: 1.422 - lr: 5.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5570.3 - avg_words_per_second: 2902.3 - ETA: >2024-05-25 22:00:37 +2024-05-25 20:52:24 (UTC) - 0:26:14 - train - INFO - step: 000138 - done (%): 27.6 - loss: 1.346 - lr: 5.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5554.2 - avg_words_per_second: 2912.4 - ETA: >2024-05-25 22:00:17 +2024-05-25 20:52:30 (UTC) - 0:26:20 - train - INFO - step: 000139 - done (%): 27.8 - loss: 1.388 - lr: 5.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5552.4 - avg_words_per_second: 2922.4 - ETA: >2024-05-25 21:59:58 +2024-05-25 20:52:36 (UTC) - 0:26:25 - train - INFO - step: 000140 - done (%): 28.0 - loss: 1.414 - lr: 5.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5563.3 - avg_words_per_second: 2932.3 - ETA: >2024-05-25 21:59:39 +2024-05-25 20:52:42 (UTC) - 0:26:31 - train - INFO - step: 000141 - done (%): 28.2 - loss: 1.222 - lr: 5.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5563.0 - avg_words_per_second: 2942.2 - ETA: >2024-05-25 21:59:20 +2024-05-25 20:52:48 (UTC) - 0:26:37 - train - INFO - step: 000142 - done (%): 28.4 - loss: 2.072 - lr: 5.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.5 - avg_words_per_second: 2952.0 - ETA: >2024-05-25 21:59:02 +2024-05-25 20:52:54 (UTC) - 0:26:43 - train - INFO - step: 000143 - done (%): 28.6 - loss: 1.306 - lr: 5.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5575.3 - avg_words_per_second: 2961.7 - ETA: >2024-05-25 21:58:44 +2024-05-25 20:53:00 (UTC) - 0:26:49 - train - INFO - step: 000144 - done (%): 28.8 - loss: 1.590 - lr: 5.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5548.6 - avg_words_per_second: 2971.4 - ETA: >2024-05-25 21:58:26 +2024-05-25 20:53:06 (UTC) - 0:26:55 - train - INFO - step: 000145 - done (%): 29.0 - loss: 1.955 - lr: 5.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5548.9 - avg_words_per_second: 2980.9 - ETA: >2024-05-25 21:58:08 +2024-05-25 20:53:12 (UTC) - 0:27:01 - train - INFO - step: 000146 - done (%): 29.2 - loss: 1.527 - lr: 5.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5567.5 - avg_words_per_second: 2990.4 - ETA: >2024-05-25 21:57:51 +2024-05-25 20:53:17 (UTC) - 0:27:07 - train - INFO - step: 000147 - done (%): 29.4 - loss: 1.362 - lr: 5.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.8 - avg_words_per_second: 2999.9 - ETA: >2024-05-25 21:57:33 +2024-05-25 20:53:23 (UTC) - 0:27:13 - train - INFO - step: 000148 - done (%): 29.6 - loss: 1.429 - lr: 5.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5549.0 - avg_words_per_second: 3009.2 - ETA: >2024-05-25 21:57:16 +2024-05-25 20:53:29 (UTC) - 0:27:19 - train - INFO - step: 000149 - done (%): 29.8 - loss: 1.440 - lr: 5.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5562.3 - avg_words_per_second: 3018.5 - ETA: >2024-05-25 21:57:00 +2024-05-25 20:53:35 (UTC) - 0:27:24 - train - INFO - step: 000150 - done (%): 30.0 - loss: 1.680 - lr: 5.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5548.6 - avg_words_per_second: 3027.7 - ETA: >2024-05-25 21:56:43 +2024-05-25 20:53:41 (UTC) - 0:27:30 - train - INFO - step: 000151 - done (%): 30.2 - loss: 1.964 - lr: 5.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.3 - avg_words_per_second: 3036.8 - ETA: >2024-05-25 21:56:27 +2024-05-25 20:53:47 (UTC) - 0:27:36 - train - INFO - step: 000152 - done (%): 30.4 - loss: 0.657 - lr: 5.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.2 - avg_words_per_second: 3045.9 - ETA: >2024-05-25 21:56:11 +2024-05-25 20:53:53 (UTC) - 0:27:42 - train - INFO - step: 000153 - done (%): 30.6 - loss: 1.546 - lr: 5.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5553.9 - avg_words_per_second: 3055.0 - ETA: >2024-05-25 21:55:55 +2024-05-25 20:53:59 (UTC) - 0:27:48 - train - INFO - step: 000154 - done (%): 30.8 - loss: 2.111 - lr: 5.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5541.5 - avg_words_per_second: 3063.9 - ETA: >2024-05-25 21:55:39 +2024-05-25 20:54:05 (UTC) - 0:27:54 - train - INFO - step: 000155 - done (%): 31.0 - loss: 1.604 - lr: 5.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5558.5 - avg_words_per_second: 3072.8 - ETA: >2024-05-25 21:55:24 +2024-05-25 20:54:11 (UTC) - 0:28:00 - train - INFO - step: 000156 - done (%): 31.2 - loss: 1.624 - lr: 4.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.6 - avg_words_per_second: 3081.6 - ETA: >2024-05-25 21:55:08 +2024-05-25 20:54:16 (UTC) - 0:28:06 - train - INFO - step: 000157 - done (%): 31.4 - loss: 1.762 - lr: 4.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5570.1 - avg_words_per_second: 3090.4 - ETA: >2024-05-25 21:54:53 +2024-05-25 20:54:22 (UTC) - 0:28:12 - train - INFO - step: 000158 - done (%): 31.6 - loss: 1.553 - lr: 4.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5553.0 - avg_words_per_second: 3099.1 - ETA: >2024-05-25 21:54:38 +2024-05-25 20:54:28 (UTC) - 0:28:18 - train - INFO - step: 000159 - done (%): 31.8 - loss: 1.457 - lr: 4.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.1 - avg_words_per_second: 3107.8 - ETA: >2024-05-25 21:54:24 +2024-05-25 20:54:34 (UTC) - 0:28:23 - train - INFO - step: 000160 - done (%): 32.0 - loss: 1.502 - lr: 4.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.7 - avg_words_per_second: 3116.4 - ETA: >2024-05-25 21:54:09 +2024-05-25 20:54:40 (UTC) - 0:28:29 - train - INFO - step: 000161 - done (%): 32.2 - loss: 1.493 - lr: 4.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.6 - avg_words_per_second: 3124.9 - ETA: >2024-05-25 21:53:55 +2024-05-25 20:54:46 (UTC) - 0:28:35 - train - INFO - step: 000162 - done (%): 32.4 - loss: 1.964 - lr: 4.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5553.6 - avg_words_per_second: 3133.3 - ETA: >2024-05-25 21:53:41 +2024-05-25 20:54:52 (UTC) - 0:28:41 - train - INFO - step: 000163 - done (%): 32.6 - loss: 1.458 - lr: 4.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.2 - avg_words_per_second: 3141.8 - ETA: >2024-05-25 21:53:27 +2024-05-25 20:54:58 (UTC) - 0:28:47 - train - INFO - step: 000164 - done (%): 32.8 - loss: 1.364 - lr: 4.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5547.1 - avg_words_per_second: 3150.1 - ETA: >2024-05-25 21:53:13 +2024-05-25 20:55:04 (UTC) - 0:28:53 - train - INFO - step: 000165 - done (%): 33.0 - loss: 1.365 - lr: 4.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.4 - avg_words_per_second: 3158.4 - ETA: >2024-05-25 21:52:59 +2024-05-25 20:55:10 (UTC) - 0:28:59 - train - INFO - step: 000166 - done (%): 33.2 - loss: 1.230 - lr: 4.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5546.5 - avg_words_per_second: 3166.6 - ETA: >2024-05-25 21:52:46 +2024-05-25 20:55:15 (UTC) - 0:29:05 - train - INFO - step: 000167 - done (%): 33.4 - loss: 1.459 - lr: 4.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5562.8 - avg_words_per_second: 3174.8 - ETA: >2024-05-25 21:52:32 +2024-05-25 20:55:21 (UTC) - 0:29:11 - train - INFO - step: 000168 - done (%): 33.6 - loss: 1.403 - lr: 4.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5554.2 - avg_words_per_second: 3182.9 - ETA: >2024-05-25 21:52:19 +2024-05-25 20:55:27 (UTC) - 0:29:17 - train - INFO - step: 000169 - done (%): 33.8 - loss: 1.238 - lr: 4.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5557.9 - avg_words_per_second: 3191.0 - ETA: >2024-05-25 21:52:06 +2024-05-25 20:55:33 (UTC) - 0:29:22 - train - INFO - step: 000170 - done (%): 34.0 - loss: 1.375 - lr: 4.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.7 - avg_words_per_second: 3199.0 - ETA: >2024-05-25 21:51:53 +2024-05-25 20:55:39 (UTC) - 0:29:28 - train - INFO - step: 000171 - done (%): 34.2 - loss: 1.629 - lr: 4.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5541.9 - avg_words_per_second: 3206.9 - ETA: >2024-05-25 21:51:41 +2024-05-25 20:55:45 (UTC) - 0:29:34 - train - INFO - step: 000172 - done (%): 34.4 - loss: 1.377 - lr: 4.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.2 - avg_words_per_second: 3214.8 - ETA: >2024-05-25 21:51:28 +2024-05-25 20:55:51 (UTC) - 0:29:40 - train - INFO - step: 000173 - done (%): 34.6 - loss: 1.637 - lr: 4.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.8 - avg_words_per_second: 3222.7 - ETA: >2024-05-25 21:51:16 +2024-05-25 20:55:57 (UTC) - 0:29:46 - train - INFO - step: 000174 - done (%): 34.8 - loss: 1.211 - lr: 4.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5551.2 - avg_words_per_second: 3230.5 - ETA: >2024-05-25 21:51:04 +2024-05-25 20:56:03 (UTC) - 0:29:52 - train - INFO - step: 000175 - done (%): 35.0 - loss: 1.542 - lr: 4.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5558.1 - avg_words_per_second: 3238.2 - ETA: >2024-05-25 21:50:51 +2024-05-25 20:56:09 (UTC) - 0:29:58 - train - INFO - step: 000176 - done (%): 35.2 - loss: 1.251 - lr: 4.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.8 - avg_words_per_second: 3245.9 - ETA: >2024-05-25 21:50:39 +2024-05-25 20:56:14 (UTC) - 0:30:04 - train - INFO - step: 000177 - done (%): 35.4 - loss: 1.512 - lr: 4.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5539.5 - avg_words_per_second: 3253.5 - ETA: >2024-05-25 21:50:28 +2024-05-25 20:56:20 (UTC) - 0:30:10 - train - INFO - step: 000178 - done (%): 35.6 - loss: 1.587 - lr: 4.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.5 - avg_words_per_second: 3261.1 - ETA: >2024-05-25 21:50:16 +2024-05-25 20:56:26 (UTC) - 0:30:16 - train - INFO - step: 000179 - done (%): 35.8 - loss: 1.634 - lr: 4.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5552.8 - avg_words_per_second: 3268.6 - ETA: >2024-05-25 21:50:04 +2024-05-25 20:56:32 (UTC) - 0:30:21 - train - INFO - step: 000180 - done (%): 36.0 - loss: 1.179 - lr: 4.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.5 - avg_words_per_second: 3276.1 - ETA: >2024-05-25 21:49:53 +2024-05-25 20:56:38 (UTC) - 0:30:27 - train - INFO - step: 000181 - done (%): 36.2 - loss: 1.535 - lr: 4.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.7 - avg_words_per_second: 3283.6 - ETA: >2024-05-25 21:49:41 +2024-05-25 20:56:44 (UTC) - 0:30:33 - train - INFO - step: 000182 - done (%): 36.4 - loss: 1.073 - lr: 4.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.0 - avg_words_per_second: 3291.0 - ETA: >2024-05-25 21:49:30 +2024-05-25 20:56:50 (UTC) - 0:30:39 - train - INFO - step: 000183 - done (%): 36.6 - loss: 1.295 - lr: 4.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.7 - avg_words_per_second: 3298.3 - ETA: >2024-05-25 21:49:19 +2024-05-25 20:56:56 (UTC) - 0:30:45 - train - INFO - step: 000184 - done (%): 36.8 - loss: 1.867 - lr: 4.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5550.0 - avg_words_per_second: 3305.6 - ETA: >2024-05-25 21:49:08 +2024-05-25 20:57:02 (UTC) - 0:30:51 - train - INFO - step: 000185 - done (%): 37.0 - loss: 1.445 - lr: 4.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5542.1 - avg_words_per_second: 3312.9 - ETA: >2024-05-25 21:48:57 +2024-05-25 20:57:08 (UTC) - 0:30:57 - train - INFO - step: 000186 - done (%): 37.2 - loss: 1.044 - lr: 4.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5554.1 - avg_words_per_second: 3320.1 - ETA: >2024-05-25 21:48:47 +2024-05-25 20:57:13 (UTC) - 0:31:03 - train - INFO - step: 000187 - done (%): 37.4 - loss: 1.717 - lr: 4.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5557.7 - avg_words_per_second: 3327.2 - ETA: >2024-05-25 21:48:36 +2024-05-25 20:57:19 (UTC) - 0:31:09 - train - INFO - step: 000188 - done (%): 37.6 - loss: 1.867 - lr: 4.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.7 - avg_words_per_second: 3334.4 - ETA: >2024-05-25 21:48:26 +2024-05-25 20:57:25 (UTC) - 0:31:15 - train - INFO - step: 000189 - done (%): 37.8 - loss: 1.542 - lr: 4.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5567.4 - avg_words_per_second: 3341.4 - ETA: >2024-05-25 21:48:15 +2024-05-25 20:57:31 (UTC) - 0:31:20 - train - INFO - step: 000190 - done (%): 38.0 - loss: 1.401 - lr: 4.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5551.4 - avg_words_per_second: 3348.5 - ETA: >2024-05-25 21:48:05 +2024-05-25 20:57:37 (UTC) - 0:31:26 - train - INFO - step: 000191 - done (%): 38.2 - loss: 1.589 - lr: 4.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5552.9 - avg_words_per_second: 3355.4 - ETA: >2024-05-25 21:47:55 +2024-05-25 20:57:43 (UTC) - 0:31:32 - train - INFO - step: 000192 - done (%): 38.4 - loss: 1.784 - lr: 4.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.9 - avg_words_per_second: 3362.4 - ETA: >2024-05-25 21:47:45 +2024-05-25 20:57:49 (UTC) - 0:31:38 - train - INFO - step: 000193 - done (%): 38.6 - loss: 1.062 - lr: 4.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5547.2 - avg_words_per_second: 3369.2 - ETA: >2024-05-25 21:47:35 +2024-05-25 20:57:55 (UTC) - 0:31:44 - train - INFO - step: 000194 - done (%): 38.8 - loss: 1.829 - lr: 4.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5503.9 - avg_words_per_second: 3376.0 - ETA: >2024-05-25 21:47:25 +2024-05-25 20:58:01 (UTC) - 0:31:50 - train - INFO - step: 000195 - done (%): 39.0 - loss: 1.675 - lr: 4.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5557.0 - avg_words_per_second: 3382.8 - ETA: >2024-05-25 21:47:15 +2024-05-25 20:58:07 (UTC) - 0:31:56 - train - INFO - step: 000196 - done (%): 39.2 - loss: 1.352 - lr: 4.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5565.2 - avg_words_per_second: 3389.6 - ETA: >2024-05-25 21:47:05 +2024-05-25 20:58:13 (UTC) - 0:32:02 - train - INFO - step: 000197 - done (%): 39.4 - loss: 1.479 - lr: 4.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5552.4 - avg_words_per_second: 3396.3 - ETA: >2024-05-25 21:46:56 +2024-05-25 20:58:18 (UTC) - 0:32:08 - train - INFO - step: 000198 - done (%): 39.6 - loss: 1.624 - lr: 4.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5575.7 - avg_words_per_second: 3403.0 - ETA: >2024-05-25 21:46:46 +2024-05-25 20:58:24 (UTC) - 0:32:14 - train - INFO - step: 000199 - done (%): 39.8 - loss: 1.638 - lr: 4.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.7 - avg_words_per_second: 3409.7 - ETA: >2024-05-25 21:46:37 +2024-05-25 20:58:30 (UTC) - 0:32:19 - train - INFO - step: 000200 - done (%): 40.0 - loss: 1.127 - lr: 4.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5546.0 - avg_words_per_second: 3416.2 - ETA: >2024-05-25 21:46:28 +2024-05-25 20:58:30 (UTC) - 0:32:19 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runs2/checkpoints/checkpoint_000200/consolidated using tmp name: tmp.consolidated +2024-05-25 20:58:45 (UTC) - 0:32:34 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runs2/checkpoints/checkpoint_000200/consolidated for step: 200 +2024-05-25 20:58:45 (UTC) - 0:32:34 - checkpointing - INFO - Done deleting checkpoints +2024-05-25 20:58:45 (UTC) - 0:32:34 - checkpointing - INFO - Done! +2024-05-25 20:58:50 (UTC) - 0:32:40 - train - INFO - step: 000201 - done (%): 40.2 - loss: 1.736 - lr: 4.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5631.6 - avg_words_per_second: 3422.9 - ETA: >2024-05-25 21:46:33 +2024-05-25 20:58:56 (UTC) - 0:32:45 - train - INFO - step: 000202 - done (%): 40.4 - loss: 1.388 - lr: 4.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5623.1 - avg_words_per_second: 3429.6 - ETA: >2024-05-25 21:46:23 +2024-05-25 20:59:02 (UTC) - 0:32:51 - train - INFO - step: 000203 - done (%): 40.6 - loss: 1.279 - lr: 4.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5593.5 - avg_words_per_second: 3436.1 - ETA: >2024-05-25 21:46:14 +2024-05-25 20:59:08 (UTC) - 0:32:57 - train - INFO - step: 000204 - done (%): 40.8 - loss: 1.546 - lr: 4.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5586.3 - avg_words_per_second: 3442.6 - ETA: >2024-05-25 21:46:05 +2024-05-25 20:59:14 (UTC) - 0:33:03 - train - INFO - step: 000205 - done (%): 41.0 - loss: 1.886 - lr: 4.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5565.6 - avg_words_per_second: 3449.1 - ETA: >2024-05-25 21:45:56 +2024-05-25 20:59:20 (UTC) - 0:33:09 - train - INFO - step: 000206 - done (%): 41.2 - loss: 1.854 - lr: 4.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5575.4 - avg_words_per_second: 3455.4 - ETA: >2024-05-25 21:45:48 +2024-05-25 20:59:26 (UTC) - 0:33:15 - train - INFO - step: 000207 - done (%): 41.4 - loss: 1.061 - lr: 4.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5571.6 - avg_words_per_second: 3461.8 - ETA: >2024-05-25 21:45:39 +2024-05-25 20:59:31 (UTC) - 0:33:21 - train - INFO - step: 000208 - done (%): 41.6 - loss: 1.712 - lr: 4.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5572.7 - avg_words_per_second: 3468.1 - ETA: >2024-05-25 21:45:30 +2024-05-25 20:59:37 (UTC) - 0:33:27 - train - INFO - step: 000209 - done (%): 41.8 - loss: 1.362 - lr: 4.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5569.7 - avg_words_per_second: 3474.4 - ETA: >2024-05-25 21:45:22 +2024-05-25 20:59:43 (UTC) - 0:33:32 - train - INFO - step: 000210 - done (%): 42.0 - loss: 1.149 - lr: 4.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5543.9 - avg_words_per_second: 3480.6 - ETA: >2024-05-25 21:45:13 +2024-05-25 20:59:49 (UTC) - 0:33:38 - train - INFO - step: 000211 - done (%): 42.2 - loss: 1.664 - lr: 4.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5554.2 - avg_words_per_second: 3486.7 - ETA: >2024-05-25 21:45:05 +2024-05-25 20:59:55 (UTC) - 0:33:44 - train - INFO - step: 000212 - done (%): 42.4 - loss: 1.540 - lr: 4.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.8 - avg_words_per_second: 3492.9 - ETA: >2024-05-25 21:44:57 +2024-05-25 21:00:01 (UTC) - 0:33:50 - train - INFO - step: 000213 - done (%): 42.6 - loss: 1.721 - lr: 4.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5567.5 - avg_words_per_second: 3499.0 - ETA: >2024-05-25 21:44:49 +2024-05-25 21:00:07 (UTC) - 0:33:56 - train - INFO - step: 000214 - done (%): 42.8 - loss: 1.124 - lr: 3.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.8 - avg_words_per_second: 3505.1 - ETA: >2024-05-25 21:44:41 +2024-05-25 21:00:13 (UTC) - 0:34:02 - train - INFO - step: 000215 - done (%): 43.0 - loss: 1.082 - lr: 3.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.1 - avg_words_per_second: 3511.1 - ETA: >2024-05-25 21:44:32 +2024-05-25 21:00:19 (UTC) - 0:34:08 - train - INFO - step: 000216 - done (%): 43.2 - loss: 1.167 - lr: 3.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5553.4 - avg_words_per_second: 3517.1 - ETA: >2024-05-25 21:44:25 +2024-05-25 21:00:24 (UTC) - 0:34:14 - train - INFO - step: 000217 - done (%): 43.4 - loss: 1.325 - lr: 3.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5570.5 - avg_words_per_second: 3523.1 - ETA: >2024-05-25 21:44:17 +2024-05-25 21:00:30 (UTC) - 0:34:20 - train - INFO - step: 000218 - done (%): 43.6 - loss: 1.806 - lr: 3.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5550.2 - avg_words_per_second: 3529.0 - ETA: >2024-05-25 21:44:09 +2024-05-25 21:00:36 (UTC) - 0:34:26 - train - INFO - step: 000219 - done (%): 43.8 - loss: 1.219 - lr: 3.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.6 - avg_words_per_second: 3534.9 - ETA: >2024-05-25 21:44:01 +2024-05-25 21:00:42 (UTC) - 0:34:31 - train - INFO - step: 000220 - done (%): 44.0 - loss: 1.774 - lr: 3.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5554.1 - avg_words_per_second: 3540.8 - ETA: >2024-05-25 21:43:53 +2024-05-25 21:00:48 (UTC) - 0:34:37 - train - INFO - step: 000221 - done (%): 44.2 - loss: 1.700 - lr: 3.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.7 - avg_words_per_second: 3546.6 - ETA: >2024-05-25 21:43:46 +2024-05-25 21:00:54 (UTC) - 0:34:43 - train - INFO - step: 000222 - done (%): 44.4 - loss: 1.481 - lr: 3.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.5 - avg_words_per_second: 3552.4 - ETA: >2024-05-25 21:43:38 +2024-05-25 21:01:00 (UTC) - 0:34:49 - train - INFO - step: 000223 - done (%): 44.6 - loss: 1.026 - lr: 3.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5568.4 - avg_words_per_second: 3558.2 - ETA: >2024-05-25 21:43:31 +2024-05-25 21:01:06 (UTC) - 0:34:55 - train - INFO - step: 000224 - done (%): 44.8 - loss: 1.577 - lr: 3.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5563.5 - avg_words_per_second: 3563.9 - ETA: >2024-05-25 21:43:23 +2024-05-25 21:01:12 (UTC) - 0:35:01 - train - INFO - step: 000225 - done (%): 45.0 - loss: 1.392 - lr: 3.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5565.3 - avg_words_per_second: 3569.6 - ETA: >2024-05-25 21:43:16 +2024-05-25 21:01:18 (UTC) - 0:35:07 - train - INFO - step: 000226 - done (%): 45.2 - loss: 1.491 - lr: 3.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5552.8 - avg_words_per_second: 3575.3 - ETA: >2024-05-25 21:43:09 +2024-05-25 21:01:23 (UTC) - 0:35:13 - train - INFO - step: 000227 - done (%): 45.4 - loss: 1.416 - lr: 3.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5569.1 - avg_words_per_second: 3580.9 - ETA: >2024-05-25 21:43:02 +2024-05-25 21:01:42 (UTC) - 0:35:31 - train - INFO - step: 000228 - done (%): 45.6 - loss: 1.732 - lr: 3.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 1800.5 - avg_words_per_second: 3565.5 - ETA: >2024-05-25 21:43:21 +2024-05-25 21:01:47 (UTC) - 0:35:37 - train - INFO - step: 000229 - done (%): 45.8 - loss: 1.251 - lr: 3.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5617.4 - avg_words_per_second: 3571.2 - ETA: >2024-05-25 21:43:14 +2024-05-25 21:01:53 (UTC) - 0:35:43 - train - INFO - step: 000230 - done (%): 46.0 - loss: 1.450 - lr: 3.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5586.8 - avg_words_per_second: 3576.8 - ETA: >2024-05-25 21:43:07 +2024-05-25 21:01:59 (UTC) - 0:35:48 - train - INFO - step: 000231 - done (%): 46.2 - loss: 1.702 - lr: 3.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5577.7 - avg_words_per_second: 3582.3 - ETA: >2024-05-25 21:43:00 +2024-05-25 21:02:05 (UTC) - 0:35:54 - train - INFO - step: 000232 - done (%): 46.4 - loss: 1.403 - lr: 3.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5575.6 - avg_words_per_second: 3587.9 - ETA: >2024-05-25 21:42:53 +2024-05-25 21:02:11 (UTC) - 0:36:00 - train - INFO - step: 000233 - done (%): 46.6 - loss: 1.580 - lr: 3.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5587.6 - avg_words_per_second: 3593.4 - ETA: >2024-05-25 21:42:46 +2024-05-25 21:02:17 (UTC) - 0:36:06 - train - INFO - step: 000234 - done (%): 46.8 - loss: 1.676 - lr: 3.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5575.8 - avg_words_per_second: 3598.9 - ETA: >2024-05-25 21:42:39 +2024-05-25 21:02:23 (UTC) - 0:36:12 - train - INFO - step: 000235 - done (%): 47.0 - loss: 1.491 - lr: 3.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5568.5 - avg_words_per_second: 3604.3 - ETA: >2024-05-25 21:42:32 +2024-05-25 21:02:29 (UTC) - 0:36:18 - train - INFO - step: 000236 - done (%): 47.2 - loss: 1.609 - lr: 3.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5571.6 - avg_words_per_second: 3609.7 - ETA: >2024-05-25 21:42:25 +2024-05-25 21:02:34 (UTC) - 0:36:24 - train - INFO - step: 000237 - done (%): 47.4 - loss: 1.525 - lr: 3.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.9 - avg_words_per_second: 3615.1 - ETA: >2024-05-25 21:42:18 +2024-05-25 21:02:40 (UTC) - 0:36:30 - train - INFO - step: 000238 - done (%): 47.6 - loss: 1.246 - lr: 3.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.2 - avg_words_per_second: 3620.4 - ETA: >2024-05-25 21:42:12 +2024-05-25 21:02:46 (UTC) - 0:36:36 - train - INFO - step: 000239 - done (%): 47.8 - loss: 1.543 - lr: 3.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5563.9 - avg_words_per_second: 3625.7 - ETA: >2024-05-25 21:42:05 +2024-05-25 21:02:52 (UTC) - 0:36:41 - train - INFO - step: 000240 - done (%): 48.0 - loss: 1.927 - lr: 3.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5550.3 - avg_words_per_second: 3630.9 - ETA: >2024-05-25 21:41:59 +2024-05-25 21:02:58 (UTC) - 0:36:47 - train - INFO - step: 000241 - done (%): 48.2 - loss: 1.061 - lr: 3.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.0 - avg_words_per_second: 3636.1 - ETA: >2024-05-25 21:41:52 +2024-05-25 21:03:04 (UTC) - 0:36:53 - train - INFO - step: 000242 - done (%): 48.4 - loss: 1.178 - lr: 3.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5560.1 - avg_words_per_second: 3641.4 - ETA: >2024-05-25 21:41:46 +2024-05-25 21:03:10 (UTC) - 0:36:59 - train - INFO - step: 000243 - done (%): 48.6 - loss: 1.865 - lr: 3.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5562.5 - avg_words_per_second: 3646.5 - ETA: >2024-05-25 21:41:39 +2024-05-25 21:03:16 (UTC) - 0:37:05 - train - INFO - step: 000244 - done (%): 48.8 - loss: 1.201 - lr: 3.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5549.9 - avg_words_per_second: 3651.7 - ETA: >2024-05-25 21:41:33 +2024-05-25 21:03:22 (UTC) - 0:37:11 - train - INFO - step: 000245 - done (%): 49.0 - loss: 1.422 - lr: 3.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.4 - avg_words_per_second: 3656.8 - ETA: >2024-05-25 21:41:27 +2024-05-25 21:03:28 (UTC) - 0:37:17 - train - INFO - step: 000246 - done (%): 49.2 - loss: 1.523 - lr: 3.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5560.3 - avg_words_per_second: 3661.9 - ETA: >2024-05-25 21:41:20 +2024-05-25 21:03:33 (UTC) - 0:37:23 - train - INFO - step: 000247 - done (%): 49.4 - loss: 1.608 - lr: 3.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.0 - avg_words_per_second: 3667.0 - ETA: >2024-05-25 21:41:14 +2024-05-25 21:03:39 (UTC) - 0:37:29 - train - INFO - step: 000248 - done (%): 49.6 - loss: 1.339 - lr: 3.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5552.4 - avg_words_per_second: 3672.0 - ETA: >2024-05-25 21:41:08 +2024-05-25 21:03:45 (UTC) - 0:37:34 - train - INFO - step: 000249 - done (%): 49.8 - loss: 1.610 - lr: 3.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.4 - avg_words_per_second: 3677.0 - ETA: >2024-05-25 21:41:02 +2024-05-25 21:03:51 (UTC) - 0:37:40 - train - INFO - step: 000250 - done (%): 50.0 - loss: 1.421 - lr: 3.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5553.3 - avg_words_per_second: 3682.0 - ETA: >2024-05-25 21:40:56 +2024-05-25 21:03:57 (UTC) - 0:37:46 - train - INFO - step: 000251 - done (%): 50.2 - loss: 1.100 - lr: 3.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5571.0 - avg_words_per_second: 3686.9 - ETA: >2024-05-25 21:40:50 +2024-05-25 21:04:03 (UTC) - 0:37:52 - train - INFO - step: 000252 - done (%): 50.4 - loss: 1.928 - lr: 3.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5563.0 - avg_words_per_second: 3691.9 - ETA: >2024-05-25 21:40:44 +2024-05-25 21:04:09 (UTC) - 0:37:58 - train - INFO - step: 000253 - done (%): 50.6 - loss: 1.423 - lr: 3.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5554.9 - avg_words_per_second: 3696.8 - ETA: >2024-05-25 21:40:38 +2024-05-25 21:04:15 (UTC) - 0:38:04 - train - INFO - step: 000254 - done (%): 50.8 - loss: 1.438 - lr: 3.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.4 - avg_words_per_second: 3701.7 - ETA: >2024-05-25 21:40:32 +2024-05-25 21:04:21 (UTC) - 0:38:10 - train - INFO - step: 000255 - done (%): 51.0 - loss: 1.645 - lr: 3.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.9 - avg_words_per_second: 3706.5 - ETA: >2024-05-25 21:40:27 +2024-05-25 21:04:26 (UTC) - 0:38:16 - train - INFO - step: 000256 - done (%): 51.2 - loss: 1.298 - lr: 3.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5567.5 - avg_words_per_second: 3711.4 - ETA: >2024-05-25 21:40:21 +2024-05-25 21:04:32 (UTC) - 0:38:22 - train - INFO - step: 000257 - done (%): 51.4 - loss: 1.347 - lr: 3.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5567.7 - avg_words_per_second: 3716.2 - ETA: >2024-05-25 21:40:15 +2024-05-25 21:04:38 (UTC) - 0:38:28 - train - INFO - step: 000258 - done (%): 51.6 - loss: 1.524 - lr: 3.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5554.1 - avg_words_per_second: 3721.0 - ETA: >2024-05-25 21:40:09 +2024-05-25 21:04:44 (UTC) - 0:38:33 - train - INFO - step: 000259 - done (%): 51.8 - loss: 1.472 - lr: 3.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.8 - avg_words_per_second: 3725.7 - ETA: >2024-05-25 21:40:04 +2024-05-25 21:04:50 (UTC) - 0:38:39 - train - INFO - step: 000260 - done (%): 52.0 - loss: 1.855 - lr: 3.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5563.8 - avg_words_per_second: 3730.5 - ETA: >2024-05-25 21:39:58 +2024-05-25 21:04:56 (UTC) - 0:38:45 - train - INFO - step: 000261 - done (%): 52.2 - loss: 1.778 - lr: 3.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.2 - avg_words_per_second: 3735.2 - ETA: >2024-05-25 21:39:53 +2024-05-25 21:05:02 (UTC) - 0:38:51 - train - INFO - step: 000262 - done (%): 52.4 - loss: 1.297 - lr: 3.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5552.9 - avg_words_per_second: 3739.9 - ETA: >2024-05-25 21:39:47 +2024-05-25 21:05:08 (UTC) - 0:38:57 - train - INFO - step: 000263 - done (%): 52.6 - loss: 1.407 - lr: 3.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5560.9 - avg_words_per_second: 3744.5 - ETA: >2024-05-25 21:39:42 +2024-05-25 21:05:14 (UTC) - 0:39:03 - train - INFO - step: 000264 - done (%): 52.8 - loss: 1.588 - lr: 3.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5553.4 - avg_words_per_second: 3749.1 - ETA: >2024-05-25 21:39:36 +2024-05-25 21:05:20 (UTC) - 0:39:09 - train - INFO - step: 000265 - done (%): 53.0 - loss: 1.161 - lr: 3.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5570.3 - avg_words_per_second: 3753.8 - ETA: >2024-05-25 21:39:31 +2024-05-25 21:05:25 (UTC) - 0:39:15 - train - INFO - step: 000266 - done (%): 53.2 - loss: 1.039 - lr: 2.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.7 - avg_words_per_second: 3758.4 - ETA: >2024-05-25 21:39:26 +2024-05-25 21:05:31 (UTC) - 0:39:21 - train - INFO - step: 000267 - done (%): 53.4 - loss: 1.490 - lr: 2.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5562.3 - avg_words_per_second: 3762.9 - ETA: >2024-05-25 21:39:20 +2024-05-25 21:05:37 (UTC) - 0:39:26 - train - INFO - step: 000268 - done (%): 53.6 - loss: 1.740 - lr: 2.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.7 - avg_words_per_second: 3767.5 - ETA: >2024-05-25 21:39:15 +2024-05-25 21:05:43 (UTC) - 0:39:32 - train - INFO - step: 000269 - done (%): 53.8 - loss: 1.641 - lr: 2.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.6 - avg_words_per_second: 3772.0 - ETA: >2024-05-25 21:39:10 +2024-05-25 21:05:49 (UTC) - 0:39:38 - train - INFO - step: 000270 - done (%): 54.0 - loss: 1.558 - lr: 2.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.5 - avg_words_per_second: 3776.5 - ETA: >2024-05-25 21:39:05 +2024-05-25 21:05:55 (UTC) - 0:39:44 - train - INFO - step: 000271 - done (%): 54.2 - loss: 1.314 - lr: 2.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5557.4 - avg_words_per_second: 3780.9 - ETA: >2024-05-25 21:39:00 +2024-05-25 21:06:01 (UTC) - 0:39:50 - train - INFO - step: 000272 - done (%): 54.4 - loss: 1.473 - lr: 2.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5565.3 - avg_words_per_second: 3785.4 - ETA: >2024-05-25 21:38:54 +2024-05-25 21:06:07 (UTC) - 0:39:56 - train - INFO - step: 000273 - done (%): 54.6 - loss: 1.215 - lr: 2.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5552.0 - avg_words_per_second: 3789.8 - ETA: >2024-05-25 21:38:49 +2024-05-25 21:06:13 (UTC) - 0:40:02 - train - INFO - step: 000274 - done (%): 54.8 - loss: 1.835 - lr: 2.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.3 - avg_words_per_second: 3794.2 - ETA: >2024-05-25 21:38:44 +2024-05-25 21:06:18 (UTC) - 0:40:08 - train - INFO - step: 000275 - done (%): 55.0 - loss: 1.972 - lr: 2.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5560.2 - avg_words_per_second: 3798.6 - ETA: >2024-05-25 21:38:39 +2024-05-25 21:06:24 (UTC) - 0:40:14 - train - INFO - step: 000276 - done (%): 55.2 - loss: 1.432 - lr: 2.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5563.0 - avg_words_per_second: 3803.0 - ETA: >2024-05-25 21:38:34 +2024-05-25 21:06:30 (UTC) - 0:40:20 - train - INFO - step: 000277 - done (%): 55.4 - loss: 1.494 - lr: 2.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5545.9 - avg_words_per_second: 3807.3 - ETA: >2024-05-25 21:38:30 +2024-05-25 21:06:36 (UTC) - 0:40:25 - train - INFO - step: 000278 - done (%): 55.6 - loss: 1.306 - lr: 2.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5569.4 - avg_words_per_second: 3811.7 - ETA: >2024-05-25 21:38:25 +2024-05-25 21:06:42 (UTC) - 0:40:31 - train - INFO - step: 000279 - done (%): 55.8 - loss: 1.792 - lr: 2.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.5 - avg_words_per_second: 3816.0 - ETA: >2024-05-25 21:38:20 +2024-05-25 21:06:48 (UTC) - 0:40:37 - train - INFO - step: 000280 - done (%): 56.0 - loss: 1.192 - lr: 2.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.9 - avg_words_per_second: 3820.2 - ETA: >2024-05-25 21:38:15 +2024-05-25 21:06:54 (UTC) - 0:40:43 - train - INFO - step: 000281 - done (%): 56.2 - loss: 1.319 - lr: 2.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5551.8 - avg_words_per_second: 3824.5 - ETA: >2024-05-25 21:38:10 +2024-05-25 21:07:00 (UTC) - 0:40:49 - train - INFO - step: 000282 - done (%): 56.4 - loss: 1.248 - lr: 2.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5560.8 - avg_words_per_second: 3828.7 - ETA: >2024-05-25 21:38:05 +2024-05-25 21:07:06 (UTC) - 0:40:55 - train - INFO - step: 000283 - done (%): 56.6 - loss: 2.071 - lr: 2.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.2 - avg_words_per_second: 3832.9 - ETA: >2024-05-25 21:38:01 +2024-05-25 21:07:12 (UTC) - 0:41:01 - train - INFO - step: 000284 - done (%): 56.8 - loss: 1.540 - lr: 2.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.1 - avg_words_per_second: 3837.1 - ETA: >2024-05-25 21:37:56 +2024-05-25 21:07:17 (UTC) - 0:41:07 - train - INFO - step: 000285 - done (%): 57.0 - loss: 1.561 - lr: 2.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5554.7 - avg_words_per_second: 3841.3 - ETA: >2024-05-25 21:37:51 +2024-05-25 21:07:23 (UTC) - 0:41:13 - train - INFO - step: 000286 - done (%): 57.2 - loss: 1.391 - lr: 2.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5573.2 - avg_words_per_second: 3845.5 - ETA: >2024-05-25 21:37:47 +2024-05-25 21:07:29 (UTC) - 0:41:18 - train - INFO - step: 000287 - done (%): 57.4 - loss: 1.616 - lr: 2.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5567.1 - avg_words_per_second: 3849.6 - ETA: >2024-05-25 21:37:42 +2024-05-25 21:07:35 (UTC) - 0:41:24 - train - INFO - step: 000288 - done (%): 57.6 - loss: 1.638 - lr: 2.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5565.8 - avg_words_per_second: 3853.8 - ETA: >2024-05-25 21:37:38 +2024-05-25 21:07:41 (UTC) - 0:41:30 - train - INFO - step: 000289 - done (%): 57.8 - loss: 1.925 - lr: 2.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.1 - avg_words_per_second: 3857.9 - ETA: >2024-05-25 21:37:33 +2024-05-25 21:07:47 (UTC) - 0:41:36 - train - INFO - step: 000290 - done (%): 58.0 - loss: 1.778 - lr: 2.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.7 - avg_words_per_second: 3861.9 - ETA: >2024-05-25 21:37:29 +2024-05-25 21:07:53 (UTC) - 0:41:42 - train - INFO - step: 000291 - done (%): 58.2 - loss: 1.620 - lr: 2.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5573.5 - avg_words_per_second: 3866.0 - ETA: >2024-05-25 21:37:24 +2024-05-25 21:07:59 (UTC) - 0:41:48 - train - INFO - step: 000292 - done (%): 58.4 - loss: 1.295 - lr: 2.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5560.5 - avg_words_per_second: 3870.0 - ETA: >2024-05-25 21:37:20 +2024-05-25 21:08:05 (UTC) - 0:41:54 - train - INFO - step: 000293 - done (%): 58.6 - loss: 1.430 - lr: 2.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5562.4 - avg_words_per_second: 3874.1 - ETA: >2024-05-25 21:37:15 +2024-05-25 21:08:10 (UTC) - 0:42:00 - train - INFO - step: 000294 - done (%): 58.8 - loss: 1.884 - lr: 2.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.1 - avg_words_per_second: 3878.1 - ETA: >2024-05-25 21:37:11 +2024-05-25 21:08:16 (UTC) - 0:42:06 - train - INFO - step: 000295 - done (%): 59.0 - loss: 1.562 - lr: 2.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5541.9 - avg_words_per_second: 3882.0 - ETA: >2024-05-25 21:37:07 +2024-05-25 21:08:22 (UTC) - 0:42:12 - train - INFO - step: 000296 - done (%): 59.2 - loss: 1.158 - lr: 2.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5565.0 - avg_words_per_second: 3886.0 - ETA: >2024-05-25 21:37:02 +2024-05-25 21:08:28 (UTC) - 0:42:17 - train - INFO - step: 000297 - done (%): 59.4 - loss: 1.469 - lr: 2.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5552.2 - avg_words_per_second: 3889.9 - ETA: >2024-05-25 21:36:58 +2024-05-25 21:08:34 (UTC) - 0:42:23 - train - INFO - step: 000298 - done (%): 59.6 - loss: 1.921 - lr: 2.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.6 - avg_words_per_second: 3893.8 - ETA: >2024-05-25 21:36:54 +2024-05-25 21:08:40 (UTC) - 0:42:29 - train - INFO - step: 000299 - done (%): 59.8 - loss: 1.836 - lr: 2.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5539.5 - avg_words_per_second: 3897.7 - ETA: >2024-05-25 21:36:50 +2024-05-25 21:08:46 (UTC) - 0:42:35 - train - INFO - step: 000300 - done (%): 60.0 - loss: 1.567 - lr: 2.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.8 - avg_words_per_second: 3901.6 - ETA: >2024-05-25 21:36:46 +2024-05-25 21:08:46 (UTC) - 0:42:35 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runs2/checkpoints/checkpoint_000300/consolidated using tmp name: tmp.consolidated +2024-05-25 21:09:01 (UTC) - 0:42:50 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runs2/checkpoints/checkpoint_000300/consolidated for step: 300 +2024-05-25 21:09:01 (UTC) - 0:42:50 - checkpointing - INFO - Done deleting checkpoints +2024-05-25 21:09:01 (UTC) - 0:42:50 - checkpointing - INFO - Done! +2024-05-25 21:09:06 (UTC) - 0:42:56 - train - INFO - step: 000301 - done (%): 60.2 - loss: 1.830 - lr: 2.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5638.5 - avg_words_per_second: 3905.6 - ETA: >2024-05-25 21:36:56 +2024-05-25 21:09:12 (UTC) - 0:43:01 - train - INFO - step: 000302 - done (%): 60.4 - loss: 1.354 - lr: 2.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5612.1 - avg_words_per_second: 3909.5 - ETA: >2024-05-25 21:36:52 +2024-05-25 21:09:18 (UTC) - 0:43:07 - train - INFO - step: 000303 - done (%): 60.6 - loss: 1.300 - lr: 2.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5592.3 - avg_words_per_second: 3913.4 - ETA: >2024-05-25 21:36:48 +2024-05-25 21:09:24 (UTC) - 0:43:13 - train - INFO - step: 000304 - done (%): 60.8 - loss: 1.725 - lr: 2.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5554.8 - avg_words_per_second: 3917.2 - ETA: >2024-05-25 21:36:44 +2024-05-25 21:09:30 (UTC) - 0:43:19 - train - INFO - step: 000305 - done (%): 61.0 - loss: 1.710 - lr: 2.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5581.1 - avg_words_per_second: 3921.1 - ETA: >2024-05-25 21:36:39 +2024-05-25 21:09:36 (UTC) - 0:43:25 - train - INFO - step: 000306 - done (%): 61.2 - loss: 1.111 - lr: 2.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5553.1 - avg_words_per_second: 3924.8 - ETA: >2024-05-25 21:36:35 +2024-05-25 21:09:42 (UTC) - 0:43:31 - train - INFO - step: 000307 - done (%): 61.4 - loss: 1.662 - lr: 2.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5585.4 - avg_words_per_second: 3928.6 - ETA: >2024-05-25 21:36:31 +2024-05-25 21:09:48 (UTC) - 0:43:37 - train - INFO - step: 000308 - done (%): 61.6 - loss: 1.489 - lr: 2.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.2 - avg_words_per_second: 3932.4 - ETA: >2024-05-25 21:36:27 +2024-05-25 21:09:53 (UTC) - 0:43:43 - train - INFO - step: 000309 - done (%): 61.8 - loss: 1.428 - lr: 2.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.0 - avg_words_per_second: 3936.1 - ETA: >2024-05-25 21:36:23 +2024-05-25 21:09:59 (UTC) - 0:43:49 - train - INFO - step: 000310 - done (%): 62.0 - loss: 1.569 - lr: 2.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.7 - avg_words_per_second: 3939.8 - ETA: >2024-05-25 21:36:20 +2024-05-25 21:10:05 (UTC) - 0:43:54 - train - INFO - step: 000311 - done (%): 62.2 - loss: 1.941 - lr: 2.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5562.1 - avg_words_per_second: 3943.5 - ETA: >2024-05-25 21:36:16 +2024-05-25 21:10:11 (UTC) - 0:44:00 - train - INFO - step: 000312 - done (%): 62.4 - loss: 2.092 - lr: 2.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5553.7 - avg_words_per_second: 3947.2 - ETA: >2024-05-25 21:36:12 +2024-05-25 21:10:17 (UTC) - 0:44:06 - train - INFO - step: 000313 - done (%): 62.6 - loss: 1.714 - lr: 2.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5536.4 - avg_words_per_second: 3950.8 - ETA: >2024-05-25 21:36:08 +2024-05-25 21:10:23 (UTC) - 0:44:12 - train - INFO - step: 000314 - done (%): 62.8 - loss: 1.417 - lr: 2.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.0 - avg_words_per_second: 3954.5 - ETA: >2024-05-25 21:36:04 +2024-05-25 21:10:29 (UTC) - 0:44:18 - train - INFO - step: 000315 - done (%): 63.0 - loss: 1.443 - lr: 2.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5542.5 - avg_words_per_second: 3958.1 - ETA: >2024-05-25 21:36:00 +2024-05-25 21:10:35 (UTC) - 0:44:24 - train - INFO - step: 000316 - done (%): 63.2 - loss: 1.580 - lr: 2.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5563.9 - avg_words_per_second: 3961.7 - ETA: >2024-05-25 21:35:57 +2024-05-25 21:10:41 (UTC) - 0:44:30 - train - INFO - step: 000317 - done (%): 63.4 - loss: 1.242 - lr: 1.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.6 - avg_words_per_second: 3965.3 - ETA: >2024-05-25 21:35:53 +2024-05-25 21:10:47 (UTC) - 0:44:36 - train - INFO - step: 000318 - done (%): 63.6 - loss: 1.344 - lr: 1.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5560.9 - avg_words_per_second: 3968.9 - ETA: >2024-05-25 21:35:49 +2024-05-25 21:10:52 (UTC) - 0:44:42 - train - INFO - step: 000319 - done (%): 63.8 - loss: 1.709 - lr: 1.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5560.2 - avg_words_per_second: 3972.4 - ETA: >2024-05-25 21:35:45 +2024-05-25 21:10:58 (UTC) - 0:44:48 - train - INFO - step: 000320 - done (%): 64.0 - loss: 1.733 - lr: 1.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5560.0 - avg_words_per_second: 3976.0 - ETA: >2024-05-25 21:35:42 +2024-05-25 21:11:04 (UTC) - 0:44:53 - train - INFO - step: 000321 - done (%): 64.2 - loss: 1.596 - lr: 1.9e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5567.4 - avg_words_per_second: 3979.5 - ETA: >2024-05-25 21:35:38 +2024-05-25 21:11:10 (UTC) - 0:44:59 - train - INFO - step: 000322 - done (%): 64.4 - loss: 1.350 - lr: 1.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5575.8 - avg_words_per_second: 3983.1 - ETA: >2024-05-25 21:35:34 +2024-05-25 21:11:16 (UTC) - 0:45:05 - train - INFO - step: 000323 - done (%): 64.6 - loss: 0.886 - lr: 1.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5562.9 - avg_words_per_second: 3986.6 - ETA: >2024-05-25 21:35:31 +2024-05-25 21:11:22 (UTC) - 0:45:11 - train - INFO - step: 000324 - done (%): 64.8 - loss: 1.125 - lr: 1.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5569.7 - avg_words_per_second: 3990.1 - ETA: >2024-05-25 21:35:27 +2024-05-25 21:11:28 (UTC) - 0:45:17 - train - INFO - step: 000325 - done (%): 65.0 - loss: 1.426 - lr: 1.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5563.3 - avg_words_per_second: 3993.5 - ETA: >2024-05-25 21:35:24 +2024-05-25 21:11:34 (UTC) - 0:45:23 - train - INFO - step: 000326 - done (%): 65.2 - loss: 1.278 - lr: 1.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5574.2 - avg_words_per_second: 3997.0 - ETA: >2024-05-25 21:35:20 +2024-05-25 21:11:39 (UTC) - 0:45:29 - train - INFO - step: 000327 - done (%): 65.4 - loss: 1.134 - lr: 1.8e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5569.1 - avg_words_per_second: 4000.5 - ETA: >2024-05-25 21:35:17 +2024-05-25 21:11:45 (UTC) - 0:45:35 - train - INFO - step: 000328 - done (%): 65.6 - loss: 1.632 - lr: 1.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5572.4 - avg_words_per_second: 4003.9 - ETA: >2024-05-25 21:35:13 +2024-05-25 21:11:51 (UTC) - 0:45:41 - train - INFO - step: 000329 - done (%): 65.8 - loss: 1.372 - lr: 1.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5562.6 - avg_words_per_second: 4007.3 - ETA: >2024-05-25 21:35:10 +2024-05-25 21:11:57 (UTC) - 0:45:46 - train - INFO - step: 000330 - done (%): 66.0 - loss: 1.849 - lr: 1.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5560.6 - avg_words_per_second: 4010.7 - ETA: >2024-05-25 21:35:06 +2024-05-25 21:12:03 (UTC) - 0:45:52 - train - INFO - step: 000331 - done (%): 66.2 - loss: 1.506 - lr: 1.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5562.7 - avg_words_per_second: 4014.1 - ETA: >2024-05-25 21:35:03 +2024-05-25 21:12:09 (UTC) - 0:45:58 - train - INFO - step: 000332 - done (%): 66.4 - loss: 1.801 - lr: 1.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.3 - avg_words_per_second: 4017.5 - ETA: >2024-05-25 21:34:59 +2024-05-25 21:12:15 (UTC) - 0:46:04 - train - INFO - step: 000333 - done (%): 66.6 - loss: 1.900 - lr: 1.7e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.9 - avg_words_per_second: 4020.8 - ETA: >2024-05-25 21:34:56 +2024-05-25 21:12:21 (UTC) - 0:46:10 - train - INFO - step: 000334 - done (%): 66.8 - loss: 1.779 - lr: 1.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5572.8 - avg_words_per_second: 4024.2 - ETA: >2024-05-25 21:34:52 +2024-05-25 21:12:27 (UTC) - 0:46:16 - train - INFO - step: 000335 - done (%): 67.0 - loss: 1.401 - lr: 1.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5567.8 - avg_words_per_second: 4027.5 - ETA: >2024-05-25 21:34:49 +2024-05-25 21:12:33 (UTC) - 0:46:22 - train - INFO - step: 000336 - done (%): 67.2 - loss: 1.657 - lr: 1.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.2 - avg_words_per_second: 4030.8 - ETA: >2024-05-25 21:34:46 +2024-05-25 21:12:38 (UTC) - 0:46:28 - train - INFO - step: 000337 - done (%): 67.4 - loss: 1.330 - lr: 1.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5568.7 - avg_words_per_second: 4034.1 - ETA: >2024-05-25 21:34:42 +2024-05-25 21:12:44 (UTC) - 0:46:34 - train - INFO - step: 000338 - done (%): 67.6 - loss: 1.353 - lr: 1.6e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5577.7 - avg_words_per_second: 4037.4 - ETA: >2024-05-25 21:34:39 +2024-05-25 21:12:50 (UTC) - 0:46:39 - train - INFO - step: 000339 - done (%): 67.8 - loss: 1.703 - lr: 1.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5550.1 - avg_words_per_second: 4040.7 - ETA: >2024-05-25 21:34:36 +2024-05-25 21:12:56 (UTC) - 0:46:45 - train - INFO - step: 000340 - done (%): 68.0 - loss: 1.808 - lr: 1.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5571.4 - avg_words_per_second: 4043.9 - ETA: >2024-05-25 21:34:33 +2024-05-25 21:13:02 (UTC) - 0:46:51 - train - INFO - step: 000341 - done (%): 68.2 - loss: 1.301 - lr: 1.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5570.2 - avg_words_per_second: 4047.2 - ETA: >2024-05-25 21:34:29 +2024-05-25 21:13:08 (UTC) - 0:46:57 - train - INFO - step: 000342 - done (%): 68.4 - loss: 1.467 - lr: 1.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.5 - avg_words_per_second: 4050.4 - ETA: >2024-05-25 21:34:26 +2024-05-25 21:13:14 (UTC) - 0:47:03 - train - INFO - step: 000343 - done (%): 68.6 - loss: 1.037 - lr: 1.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5563.0 - avg_words_per_second: 4053.6 - ETA: >2024-05-25 21:34:23 +2024-05-25 21:13:20 (UTC) - 0:47:09 - train - INFO - step: 000344 - done (%): 68.8 - loss: 1.473 - lr: 1.5e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.3 - avg_words_per_second: 4056.8 - ETA: >2024-05-25 21:34:20 +2024-05-25 21:13:26 (UTC) - 0:47:15 - train - INFO - step: 000345 - done (%): 69.0 - loss: 1.182 - lr: 1.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5560.0 - avg_words_per_second: 4060.0 - ETA: >2024-05-25 21:34:16 +2024-05-25 21:13:31 (UTC) - 0:47:21 - train - INFO - step: 000346 - done (%): 69.2 - loss: 1.688 - lr: 1.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5569.1 - avg_words_per_second: 4063.2 - ETA: >2024-05-25 21:34:13 +2024-05-25 21:13:37 (UTC) - 0:47:27 - train - INFO - step: 000347 - done (%): 69.4 - loss: 1.380 - lr: 1.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.4 - avg_words_per_second: 4066.4 - ETA: >2024-05-25 21:34:10 +2024-05-25 21:13:43 (UTC) - 0:47:32 - train - INFO - step: 000348 - done (%): 69.6 - loss: 1.509 - lr: 1.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5571.4 - avg_words_per_second: 4069.5 - ETA: >2024-05-25 21:34:07 +2024-05-25 21:13:49 (UTC) - 0:47:38 - train - INFO - step: 000349 - done (%): 69.8 - loss: 1.319 - lr: 1.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5568.4 - avg_words_per_second: 4072.7 - ETA: >2024-05-25 21:34:04 +2024-05-25 21:14:07 (UTC) - 0:47:57 - train - INFO - step: 000350 - done (%): 70.0 - loss: 1.750 - lr: 1.4e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 1791.7 - avg_words_per_second: 4057.9 - ETA: >2024-05-25 21:34:19 +2024-05-25 21:14:13 (UTC) - 0:48:02 - train - INFO - step: 000351 - done (%): 70.2 - loss: 1.287 - lr: 1.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5605.8 - avg_words_per_second: 4061.1 - ETA: >2024-05-25 21:34:15 +2024-05-25 21:14:19 (UTC) - 0:48:08 - train - INFO - step: 000352 - done (%): 70.4 - loss: 1.804 - lr: 1.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5596.8 - avg_words_per_second: 4064.3 - ETA: >2024-05-25 21:34:12 +2024-05-25 21:14:25 (UTC) - 0:48:14 - train - INFO - step: 000353 - done (%): 70.6 - loss: 0.982 - lr: 1.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5588.4 - avg_words_per_second: 4067.4 - ETA: >2024-05-25 21:34:09 +2024-05-25 21:14:31 (UTC) - 0:48:20 - train - INFO - step: 000354 - done (%): 70.8 - loss: 1.379 - lr: 1.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5553.6 - avg_words_per_second: 4070.5 - ETA: >2024-05-25 21:34:06 +2024-05-25 21:14:37 (UTC) - 0:48:26 - train - INFO - step: 000355 - done (%): 71.0 - loss: 1.762 - lr: 1.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5575.8 - avg_words_per_second: 4073.6 - ETA: >2024-05-25 21:34:03 +2024-05-25 21:14:43 (UTC) - 0:48:32 - train - INFO - step: 000356 - done (%): 71.2 - loss: 1.559 - lr: 1.3e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5572.6 - avg_words_per_second: 4076.7 - ETA: >2024-05-25 21:34:00 +2024-05-25 21:14:48 (UTC) - 0:48:38 - train - INFO - step: 000357 - done (%): 71.4 - loss: 1.062 - lr: 1.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5575.3 - avg_words_per_second: 4079.7 - ETA: >2024-05-25 21:33:57 +2024-05-25 21:14:54 (UTC) - 0:48:44 - train - INFO - step: 000358 - done (%): 71.6 - loss: 0.820 - lr: 1.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5573.7 - avg_words_per_second: 4082.8 - ETA: >2024-05-25 21:33:54 +2024-05-25 21:15:00 (UTC) - 0:48:49 - train - INFO - step: 000359 - done (%): 71.8 - loss: 1.577 - lr: 1.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5571.9 - avg_words_per_second: 4085.8 - ETA: >2024-05-25 21:33:51 +2024-05-25 21:15:06 (UTC) - 0:48:55 - train - INFO - step: 000360 - done (%): 72.0 - loss: 1.398 - lr: 1.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5539.6 - avg_words_per_second: 4088.8 - ETA: >2024-05-25 21:33:48 +2024-05-25 21:15:12 (UTC) - 0:49:01 - train - INFO - step: 000361 - done (%): 72.2 - loss: 1.665 - lr: 1.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5554.4 - avg_words_per_second: 4091.8 - ETA: >2024-05-25 21:33:45 +2024-05-25 21:15:18 (UTC) - 0:49:07 - train - INFO - step: 000362 - done (%): 72.4 - loss: 1.300 - lr: 1.2e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5569.2 - avg_words_per_second: 4094.8 - ETA: >2024-05-25 21:33:42 +2024-05-25 21:15:24 (UTC) - 0:49:13 - train - INFO - step: 000363 - done (%): 72.6 - loss: 1.022 - lr: 1.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5519.4 - avg_words_per_second: 4097.7 - ETA: >2024-05-25 21:33:39 +2024-05-25 21:15:30 (UTC) - 0:49:19 - train - INFO - step: 000364 - done (%): 72.8 - loss: 1.627 - lr: 1.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5553.4 - avg_words_per_second: 4100.7 - ETA: >2024-05-25 21:33:37 +2024-05-25 21:15:36 (UTC) - 0:49:25 - train - INFO - step: 000365 - done (%): 73.0 - loss: 1.362 - lr: 1.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.6 - avg_words_per_second: 4103.6 - ETA: >2024-05-25 21:33:34 +2024-05-25 21:15:42 (UTC) - 0:49:31 - train - INFO - step: 000366 - done (%): 73.2 - loss: 1.346 - lr: 1.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5570.1 - avg_words_per_second: 4106.6 - ETA: >2024-05-25 21:33:31 +2024-05-25 21:15:47 (UTC) - 0:49:37 - train - INFO - step: 000367 - done (%): 73.4 - loss: 1.781 - lr: 1.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5560.9 - avg_words_per_second: 4109.5 - ETA: >2024-05-25 21:33:28 +2024-05-25 21:15:53 (UTC) - 0:49:43 - train - INFO - step: 000368 - done (%): 73.6 - loss: 1.428 - lr: 1.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5569.5 - avg_words_per_second: 4112.4 - ETA: >2024-05-25 21:33:25 +2024-05-25 21:15:59 (UTC) - 0:49:48 - train - INFO - step: 000369 - done (%): 73.8 - loss: 1.081 - lr: 1.1e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.8 - avg_words_per_second: 4115.3 - ETA: >2024-05-25 21:33:22 +2024-05-25 21:16:05 (UTC) - 0:49:54 - train - INFO - step: 000370 - done (%): 74.0 - loss: 1.425 - lr: 1.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5572.8 - avg_words_per_second: 4118.3 - ETA: >2024-05-25 21:33:19 +2024-05-25 21:16:11 (UTC) - 0:50:00 - train - INFO - step: 000371 - done (%): 74.2 - loss: 1.166 - lr: 1.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5579.3 - avg_words_per_second: 4121.2 - ETA: >2024-05-25 21:33:17 +2024-05-25 21:16:17 (UTC) - 0:50:06 - train - INFO - step: 000372 - done (%): 74.4 - loss: 0.944 - lr: 1.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5562.1 - avg_words_per_second: 4124.0 - ETA: >2024-05-25 21:33:14 +2024-05-25 21:16:23 (UTC) - 0:50:12 - train - INFO - step: 000373 - done (%): 74.6 - loss: 1.727 - lr: 1.0e-05 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5569.7 - avg_words_per_second: 4126.9 - ETA: >2024-05-25 21:33:11 +2024-05-25 21:16:29 (UTC) - 0:50:18 - train - INFO - step: 000374 - done (%): 74.8 - loss: 1.217 - lr: 9.8e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5567.1 - avg_words_per_second: 4129.8 - ETA: >2024-05-25 21:33:08 +2024-05-25 21:16:35 (UTC) - 0:50:24 - train - INFO - step: 000375 - done (%): 75.0 - loss: 1.397 - lr: 9.7e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5562.5 - avg_words_per_second: 4132.6 - ETA: >2024-05-25 21:33:06 +2024-05-25 21:16:40 (UTC) - 0:50:30 - train - INFO - step: 000376 - done (%): 75.2 - loss: 1.783 - lr: 9.5e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5573.9 - avg_words_per_second: 4135.4 - ETA: >2024-05-25 21:33:03 +2024-05-25 21:16:46 (UTC) - 0:50:36 - train - INFO - step: 000377 - done (%): 75.4 - loss: 1.380 - lr: 9.4e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5543.9 - avg_words_per_second: 4138.2 - ETA: >2024-05-25 21:33:00 +2024-05-25 21:16:52 (UTC) - 0:50:41 - train - INFO - step: 000378 - done (%): 75.6 - loss: 1.704 - lr: 9.2e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5567.9 - avg_words_per_second: 4141.0 - ETA: >2024-05-25 21:32:58 +2024-05-25 21:16:58 (UTC) - 0:50:47 - train - INFO - step: 000379 - done (%): 75.8 - loss: 1.261 - lr: 9.1e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5576.1 - avg_words_per_second: 4143.9 - ETA: >2024-05-25 21:32:55 +2024-05-25 21:17:04 (UTC) - 0:50:53 - train - INFO - step: 000380 - done (%): 76.0 - loss: 1.183 - lr: 9.0e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5558.2 - avg_words_per_second: 4146.6 - ETA: >2024-05-25 21:32:52 +2024-05-25 21:17:10 (UTC) - 0:50:59 - train - INFO - step: 000381 - done (%): 76.2 - loss: 1.624 - lr: 8.8e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.9 - avg_words_per_second: 4149.4 - ETA: >2024-05-25 21:32:50 +2024-05-25 21:17:16 (UTC) - 0:51:05 - train - INFO - step: 000382 - done (%): 76.4 - loss: 1.363 - lr: 8.7e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5565.0 - avg_words_per_second: 4152.2 - ETA: >2024-05-25 21:32:47 +2024-05-25 21:17:22 (UTC) - 0:51:11 - train - INFO - step: 000383 - done (%): 76.6 - loss: 1.361 - lr: 8.5e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5550.1 - avg_words_per_second: 4154.9 - ETA: >2024-05-25 21:32:44 +2024-05-25 21:17:28 (UTC) - 0:51:17 - train - INFO - step: 000384 - done (%): 76.8 - loss: 1.651 - lr: 8.4e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5558.4 - avg_words_per_second: 4157.6 - ETA: >2024-05-25 21:32:42 +2024-05-25 21:17:33 (UTC) - 0:51:23 - train - INFO - step: 000385 - done (%): 77.0 - loss: 1.331 - lr: 8.3e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.8 - avg_words_per_second: 4160.4 - ETA: >2024-05-25 21:32:39 +2024-05-25 21:17:39 (UTC) - 0:51:29 - train - INFO - step: 000386 - done (%): 77.2 - loss: 1.288 - lr: 8.1e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5548.1 - avg_words_per_second: 4163.1 - ETA: >2024-05-25 21:32:37 +2024-05-25 21:17:45 (UTC) - 0:51:34 - train - INFO - step: 000387 - done (%): 77.4 - loss: 1.767 - lr: 8.0e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5572.4 - avg_words_per_second: 4165.8 - ETA: >2024-05-25 21:32:34 +2024-05-25 21:17:51 (UTC) - 0:51:40 - train - INFO - step: 000388 - done (%): 77.6 - loss: 1.880 - lr: 7.9e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5569.8 - avg_words_per_second: 4168.5 - ETA: >2024-05-25 21:32:32 +2024-05-25 21:17:57 (UTC) - 0:51:46 - train - INFO - step: 000389 - done (%): 77.8 - loss: 1.410 - lr: 7.7e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5571.2 - avg_words_per_second: 4171.2 - ETA: >2024-05-25 21:32:29 +2024-05-25 21:18:03 (UTC) - 0:51:52 - train - INFO - step: 000390 - done (%): 78.0 - loss: 1.585 - lr: 7.6e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5560.8 - avg_words_per_second: 4173.9 - ETA: >2024-05-25 21:32:26 +2024-05-25 21:18:09 (UTC) - 0:51:58 - train - INFO - step: 000391 - done (%): 78.2 - loss: 1.462 - lr: 7.5e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5575.1 - avg_words_per_second: 4176.6 - ETA: >2024-05-25 21:32:24 +2024-05-25 21:18:15 (UTC) - 0:52:04 - train - INFO - step: 000392 - done (%): 78.4 - loss: 1.314 - lr: 7.3e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5577.3 - avg_words_per_second: 4179.2 - ETA: >2024-05-25 21:32:21 +2024-05-25 21:18:21 (UTC) - 0:52:10 - train - INFO - step: 000393 - done (%): 78.6 - loss: 1.725 - lr: 7.2e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5570.7 - avg_words_per_second: 4181.9 - ETA: >2024-05-25 21:32:19 +2024-05-25 21:18:26 (UTC) - 0:52:16 - train - INFO - step: 000394 - done (%): 78.8 - loss: 1.870 - lr: 7.1e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5558.4 - avg_words_per_second: 4184.5 - ETA: >2024-05-25 21:32:16 +2024-05-25 21:18:32 (UTC) - 0:52:22 - train - INFO - step: 000395 - done (%): 79.0 - loss: 1.009 - lr: 6.9e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5575.5 - avg_words_per_second: 4187.2 - ETA: >2024-05-25 21:32:14 +2024-05-25 21:18:38 (UTC) - 0:52:27 - train - INFO - step: 000396 - done (%): 79.2 - loss: 1.545 - lr: 6.8e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5557.0 - avg_words_per_second: 4189.8 - ETA: >2024-05-25 21:32:12 +2024-05-25 21:18:44 (UTC) - 0:52:33 - train - INFO - step: 000397 - done (%): 79.4 - loss: 1.630 - lr: 6.7e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5569.9 - avg_words_per_second: 4192.4 - ETA: >2024-05-25 21:32:09 +2024-05-25 21:18:50 (UTC) - 0:52:39 - train - INFO - step: 000398 - done (%): 79.6 - loss: 1.604 - lr: 6.6e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5539.3 - avg_words_per_second: 4195.0 - ETA: >2024-05-25 21:32:07 +2024-05-25 21:18:56 (UTC) - 0:52:45 - train - INFO - step: 000399 - done (%): 79.8 - loss: 1.748 - lr: 6.4e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5551.9 - avg_words_per_second: 4197.5 - ETA: >2024-05-25 21:32:04 +2024-05-25 21:19:02 (UTC) - 0:52:51 - train - INFO - step: 000400 - done (%): 80.0 - loss: 1.017 - lr: 6.3e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5560.5 - avg_words_per_second: 4200.1 - ETA: >2024-05-25 21:32:02 +2024-05-25 21:19:02 (UTC) - 0:52:51 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runs2/checkpoints/checkpoint_000400/consolidated using tmp name: tmp.consolidated +2024-05-25 21:19:16 (UTC) - 0:53:06 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runs2/checkpoints/checkpoint_000400/consolidated for step: 400 +2024-05-25 21:19:17 (UTC) - 0:53:07 - checkpointing - INFO - Deleted ckpt: /root/mistral-finetune/runs2/checkpoints/checkpoint_000100 +2024-05-25 21:19:17 (UTC) - 0:53:07 - checkpointing - INFO - Done deleting checkpoints /root/mistral-finetune/runs2/checkpoints/checkpoint_000100 +2024-05-25 21:19:17 (UTC) - 0:53:07 - checkpointing - INFO - Done! +2024-05-25 21:19:23 (UTC) - 0:53:12 - train - INFO - step: 000401 - done (%): 80.2 - loss: 1.578 - lr: 6.2e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5651.9 - avg_words_per_second: 4202.8 - ETA: >2024-05-25 21:32:15 +2024-05-25 21:19:29 (UTC) - 0:53:18 - train - INFO - step: 000402 - done (%): 80.4 - loss: 1.151 - lr: 6.1e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5590.8 - avg_words_per_second: 4205.4 - ETA: >2024-05-25 21:32:13 +2024-05-25 21:19:35 (UTC) - 0:53:24 - train - INFO - step: 000403 - done (%): 80.6 - loss: 1.047 - lr: 6.0e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5602.2 - avg_words_per_second: 4208.0 - ETA: >2024-05-25 21:32:10 +2024-05-25 21:19:41 (UTC) - 0:53:30 - train - INFO - step: 000404 - done (%): 80.8 - loss: 1.222 - lr: 5.8e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5592.2 - avg_words_per_second: 4210.6 - ETA: >2024-05-25 21:32:08 +2024-05-25 21:19:47 (UTC) - 0:53:36 - train - INFO - step: 000405 - done (%): 81.0 - loss: 1.094 - lr: 5.7e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5565.9 - avg_words_per_second: 4213.1 - ETA: >2024-05-25 21:32:05 +2024-05-25 21:19:52 (UTC) - 0:53:42 - train - INFO - step: 000406 - done (%): 81.2 - loss: 1.844 - lr: 5.6e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5572.0 - avg_words_per_second: 4215.6 - ETA: >2024-05-25 21:32:03 +2024-05-25 21:19:58 (UTC) - 0:53:48 - train - INFO - step: 000407 - done (%): 81.4 - loss: 1.855 - lr: 5.5e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.3 - avg_words_per_second: 4218.2 - ETA: >2024-05-25 21:32:01 +2024-05-25 21:20:04 (UTC) - 0:53:53 - train - INFO - step: 000408 - done (%): 81.6 - loss: 1.470 - lr: 5.4e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5575.6 - avg_words_per_second: 4220.7 - ETA: >2024-05-25 21:31:58 +2024-05-25 21:20:10 (UTC) - 0:53:59 - train - INFO - step: 000409 - done (%): 81.8 - loss: 1.386 - lr: 5.3e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5575.2 - avg_words_per_second: 4223.2 - ETA: >2024-05-25 21:31:56 +2024-05-25 21:20:16 (UTC) - 0:54:05 - train - INFO - step: 000410 - done (%): 82.0 - loss: 1.719 - lr: 5.2e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5573.2 - avg_words_per_second: 4225.7 - ETA: >2024-05-25 21:31:54 +2024-05-25 21:20:22 (UTC) - 0:54:11 - train - INFO - step: 000411 - done (%): 82.2 - loss: 1.463 - lr: 5.0e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.7 - avg_words_per_second: 4228.2 - ETA: >2024-05-25 21:31:52 +2024-05-25 21:20:28 (UTC) - 0:54:17 - train - INFO - step: 000412 - done (%): 82.4 - loss: 1.689 - lr: 4.9e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5568.2 - avg_words_per_second: 4230.6 - ETA: >2024-05-25 21:31:49 +2024-05-25 21:20:34 (UTC) - 0:54:23 - train - INFO - step: 000413 - done (%): 82.6 - loss: 1.173 - lr: 4.8e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5553.1 - avg_words_per_second: 4233.1 - ETA: >2024-05-25 21:31:47 +2024-05-25 21:20:39 (UTC) - 0:54:29 - train - INFO - step: 000414 - done (%): 82.8 - loss: 1.978 - lr: 4.7e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5563.0 - avg_words_per_second: 4235.5 - ETA: >2024-05-25 21:31:45 +2024-05-25 21:20:45 (UTC) - 0:54:35 - train - INFO - step: 000415 - done (%): 83.0 - loss: 1.256 - lr: 4.6e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5558.9 - avg_words_per_second: 4237.9 - ETA: >2024-05-25 21:31:43 +2024-05-25 21:20:51 (UTC) - 0:54:41 - train - INFO - step: 000416 - done (%): 83.2 - loss: 1.423 - lr: 4.5e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.8 - avg_words_per_second: 4240.4 - ETA: >2024-05-25 21:31:40 +2024-05-25 21:20:57 (UTC) - 0:54:46 - train - INFO - step: 000417 - done (%): 83.4 - loss: 1.477 - lr: 4.4e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5548.2 - avg_words_per_second: 4242.8 - ETA: >2024-05-25 21:31:38 +2024-05-25 21:21:03 (UTC) - 0:54:52 - train - INFO - step: 000418 - done (%): 83.6 - loss: 1.132 - lr: 4.3e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5565.4 - avg_words_per_second: 4245.2 - ETA: >2024-05-25 21:31:36 +2024-05-25 21:21:09 (UTC) - 0:54:58 - train - INFO - step: 000419 - done (%): 83.8 - loss: 1.663 - lr: 4.2e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.1 - avg_words_per_second: 4247.6 - ETA: >2024-05-25 21:31:34 +2024-05-25 21:21:15 (UTC) - 0:55:04 - train - INFO - step: 000420 - done (%): 84.0 - loss: 1.247 - lr: 4.1e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5569.0 - avg_words_per_second: 4250.0 - ETA: >2024-05-25 21:31:32 +2024-05-25 21:21:21 (UTC) - 0:55:10 - train - INFO - step: 000421 - done (%): 84.2 - loss: 1.831 - lr: 4.0e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5565.7 - avg_words_per_second: 4252.4 - ETA: >2024-05-25 21:31:30 +2024-05-25 21:21:27 (UTC) - 0:55:16 - train - INFO - step: 000422 - done (%): 84.4 - loss: 1.467 - lr: 3.9e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5558.9 - avg_words_per_second: 4254.7 - ETA: >2024-05-25 21:31:27 +2024-05-25 21:21:33 (UTC) - 0:55:22 - train - INFO - step: 000423 - done (%): 84.6 - loss: 1.465 - lr: 3.8e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5548.3 - avg_words_per_second: 4257.1 - ETA: >2024-05-25 21:31:25 +2024-05-25 21:21:38 (UTC) - 0:55:28 - train - INFO - step: 000424 - done (%): 84.8 - loss: 1.316 - lr: 3.7e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.2 - avg_words_per_second: 4259.4 - ETA: >2024-05-25 21:31:23 +2024-05-25 21:21:44 (UTC) - 0:55:34 - train - INFO - step: 000425 - done (%): 85.0 - loss: 1.410 - lr: 3.6e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5572.7 - avg_words_per_second: 4261.8 - ETA: >2024-05-25 21:31:21 +2024-05-25 21:21:50 (UTC) - 0:55:39 - train - INFO - step: 000426 - done (%): 85.2 - loss: 1.342 - lr: 3.5e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5557.4 - avg_words_per_second: 4264.1 - ETA: >2024-05-25 21:31:19 +2024-05-25 21:21:56 (UTC) - 0:55:45 - train - INFO - step: 000427 - done (%): 85.4 - loss: 1.252 - lr: 3.4e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5563.7 - avg_words_per_second: 4266.5 - ETA: >2024-05-25 21:31:17 +2024-05-25 21:22:02 (UTC) - 0:55:51 - train - INFO - step: 000428 - done (%): 85.6 - loss: 1.464 - lr: 3.3e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5570.1 - avg_words_per_second: 4268.8 - ETA: >2024-05-25 21:31:15 +2024-05-25 21:22:08 (UTC) - 0:55:57 - train - INFO - step: 000429 - done (%): 85.8 - loss: 1.632 - lr: 3.2e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.1 - avg_words_per_second: 4271.1 - ETA: >2024-05-25 21:31:13 +2024-05-25 21:22:14 (UTC) - 0:56:03 - train - INFO - step: 000430 - done (%): 86.0 - loss: 2.136 - lr: 3.2e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5565.9 - avg_words_per_second: 4273.4 - ETA: >2024-05-25 21:31:11 +2024-05-25 21:22:20 (UTC) - 0:56:09 - train - INFO - step: 000431 - done (%): 86.2 - loss: 1.735 - lr: 3.1e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.9 - avg_words_per_second: 4275.7 - ETA: >2024-05-25 21:31:08 +2024-05-25 21:22:26 (UTC) - 0:56:15 - train - INFO - step: 000432 - done (%): 86.4 - loss: 0.984 - lr: 3.0e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5558.7 - avg_words_per_second: 4278.0 - ETA: >2024-05-25 21:31:06 +2024-05-25 21:22:31 (UTC) - 0:56:21 - train - INFO - step: 000433 - done (%): 86.6 - loss: 1.445 - lr: 2.9e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.7 - avg_words_per_second: 4280.3 - ETA: >2024-05-25 21:31:04 +2024-05-25 21:22:37 (UTC) - 0:56:27 - train - INFO - step: 000434 - done (%): 86.8 - loss: 1.702 - lr: 2.8e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5556.5 - avg_words_per_second: 4282.6 - ETA: >2024-05-25 21:31:02 +2024-05-25 21:22:43 (UTC) - 0:56:33 - train - INFO - step: 000435 - done (%): 87.0 - loss: 1.175 - lr: 2.7e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5544.1 - avg_words_per_second: 4284.8 - ETA: >2024-05-25 21:31:00 +2024-05-25 21:22:49 (UTC) - 0:56:38 - train - INFO - step: 000436 - done (%): 87.2 - loss: 1.380 - lr: 2.6e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.2 - avg_words_per_second: 4287.1 - ETA: >2024-05-25 21:30:58 +2024-05-25 21:22:55 (UTC) - 0:56:44 - train - INFO - step: 000437 - done (%): 87.4 - loss: 1.259 - lr: 2.6e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5557.1 - avg_words_per_second: 4289.3 - ETA: >2024-05-25 21:30:56 +2024-05-25 21:23:01 (UTC) - 0:56:50 - train - INFO - step: 000438 - done (%): 87.6 - loss: 1.151 - lr: 2.5e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.9 - avg_words_per_second: 4291.6 - ETA: >2024-05-25 21:30:54 +2024-05-25 21:23:07 (UTC) - 0:56:56 - train - INFO - step: 000439 - done (%): 87.8 - loss: 1.077 - lr: 2.4e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.8 - avg_words_per_second: 4293.8 - ETA: >2024-05-25 21:30:52 +2024-05-25 21:23:13 (UTC) - 0:57:02 - train - INFO - step: 000440 - done (%): 88.0 - loss: 1.969 - lr: 2.3e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5578.2 - avg_words_per_second: 4296.0 - ETA: >2024-05-25 21:30:50 +2024-05-25 21:23:19 (UTC) - 0:57:08 - train - INFO - step: 000441 - done (%): 88.2 - loss: 1.357 - lr: 2.3e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5563.6 - avg_words_per_second: 4298.3 - ETA: >2024-05-25 21:30:48 +2024-05-25 21:23:25 (UTC) - 0:57:14 - train - INFO - step: 000442 - done (%): 88.4 - loss: 1.482 - lr: 2.2e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.5 - avg_words_per_second: 4300.5 - ETA: >2024-05-25 21:30:46 +2024-05-25 21:23:30 (UTC) - 0:57:20 - train - INFO - step: 000443 - done (%): 88.6 - loss: 1.274 - lr: 2.1e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.8 - avg_words_per_second: 4302.7 - ETA: >2024-05-25 21:30:45 +2024-05-25 21:23:36 (UTC) - 0:57:26 - train - INFO - step: 000444 - done (%): 88.8 - loss: 1.471 - lr: 2.0e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5565.4 - avg_words_per_second: 4304.9 - ETA: >2024-05-25 21:30:43 +2024-05-25 21:23:42 (UTC) - 0:57:31 - train - INFO - step: 000445 - done (%): 89.0 - loss: 1.376 - lr: 2.0e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5540.5 - avg_words_per_second: 4307.0 - ETA: >2024-05-25 21:30:41 +2024-05-25 21:23:48 (UTC) - 0:57:37 - train - INFO - step: 000446 - done (%): 89.2 - loss: 1.420 - lr: 1.9e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5550.4 - avg_words_per_second: 4309.2 - ETA: >2024-05-25 21:30:39 +2024-05-25 21:23:54 (UTC) - 0:57:43 - train - INFO - step: 000447 - done (%): 89.4 - loss: 1.428 - lr: 1.8e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5553.4 - avg_words_per_second: 4311.4 - ETA: >2024-05-25 21:30:37 +2024-05-25 21:24:00 (UTC) - 0:57:49 - train - INFO - step: 000448 - done (%): 89.6 - loss: 0.929 - lr: 1.8e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5568.9 - avg_words_per_second: 4313.5 - ETA: >2024-05-25 21:30:35 +2024-05-25 21:24:06 (UTC) - 0:57:55 - train - INFO - step: 000449 - done (%): 89.8 - loss: 1.685 - lr: 1.7e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5576.2 - avg_words_per_second: 4315.7 - ETA: >2024-05-25 21:30:33 +2024-05-25 21:24:12 (UTC) - 0:58:01 - train - INFO - step: 000450 - done (%): 90.0 - loss: 1.786 - lr: 1.6e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5570.3 - avg_words_per_second: 4317.9 - ETA: >2024-05-25 21:30:31 +2024-05-25 21:24:18 (UTC) - 0:58:07 - train - INFO - step: 000451 - done (%): 90.2 - loss: 1.615 - lr: 1.6e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.9 - avg_words_per_second: 4320.0 - ETA: >2024-05-25 21:30:29 +2024-05-25 21:24:23 (UTC) - 0:58:13 - train - INFO - step: 000452 - done (%): 90.4 - loss: 1.247 - lr: 1.5e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5578.4 - avg_words_per_second: 4322.2 - ETA: >2024-05-25 21:30:27 +2024-05-25 21:24:29 (UTC) - 0:58:19 - train - INFO - step: 000453 - done (%): 90.6 - loss: 1.203 - lr: 1.4e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5573.7 - avg_words_per_second: 4324.3 - ETA: >2024-05-25 21:30:25 +2024-05-25 21:24:35 (UTC) - 0:58:24 - train - INFO - step: 000454 - done (%): 90.8 - loss: 1.403 - lr: 1.4e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5538.6 - avg_words_per_second: 4326.4 - ETA: >2024-05-25 21:30:24 +2024-05-25 21:24:41 (UTC) - 0:58:30 - train - INFO - step: 000455 - done (%): 91.0 - loss: 1.454 - lr: 1.3e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5571.6 - avg_words_per_second: 4328.5 - ETA: >2024-05-25 21:30:22 +2024-05-25 21:24:47 (UTC) - 0:58:36 - train - INFO - step: 000456 - done (%): 91.2 - loss: 1.674 - lr: 1.3e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5571.4 - avg_words_per_second: 4330.6 - ETA: >2024-05-25 21:30:20 +2024-05-25 21:24:53 (UTC) - 0:58:42 - train - INFO - step: 000457 - done (%): 91.4 - loss: 1.291 - lr: 1.2e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5569.9 - avg_words_per_second: 4332.7 - ETA: >2024-05-25 21:30:18 +2024-05-25 21:24:59 (UTC) - 0:58:48 - train - INFO - step: 000458 - done (%): 91.6 - loss: 1.797 - lr: 1.2e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5538.6 - avg_words_per_second: 4334.8 - ETA: >2024-05-25 21:30:16 +2024-05-25 21:25:05 (UTC) - 0:58:54 - train - INFO - step: 000459 - done (%): 91.8 - loss: 1.606 - lr: 1.1e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5562.0 - avg_words_per_second: 4336.9 - ETA: >2024-05-25 21:30:14 +2024-05-25 21:25:11 (UTC) - 0:59:00 - train - INFO - step: 000460 - done (%): 92.0 - loss: 1.683 - lr: 1.0e-06 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5568.1 - avg_words_per_second: 4339.0 - ETA: >2024-05-25 21:30:13 +2024-05-25 21:25:16 (UTC) - 0:59:06 - train - INFO - step: 000461 - done (%): 92.2 - loss: 1.364 - lr: 9.9e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5576.6 - avg_words_per_second: 4341.1 - ETA: >2024-05-25 21:30:11 +2024-05-25 21:25:22 (UTC) - 0:59:12 - train - INFO - step: 000462 - done (%): 92.4 - loss: 1.195 - lr: 9.4e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5569.4 - avg_words_per_second: 4343.1 - ETA: >2024-05-25 21:30:09 +2024-05-25 21:25:28 (UTC) - 0:59:18 - train - INFO - step: 000463 - done (%): 92.6 - loss: 1.541 - lr: 8.9e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.3 - avg_words_per_second: 4345.2 - ETA: >2024-05-25 21:30:07 +2024-05-25 21:25:34 (UTC) - 0:59:23 - train - INFO - step: 000464 - done (%): 92.8 - loss: 1.235 - lr: 8.5e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5562.7 - avg_words_per_second: 4347.2 - ETA: >2024-05-25 21:30:05 +2024-05-25 21:25:40 (UTC) - 0:59:29 - train - INFO - step: 000465 - done (%): 93.0 - loss: 1.211 - lr: 8.0e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5571.0 - avg_words_per_second: 4349.3 - ETA: >2024-05-25 21:30:04 +2024-05-25 21:25:46 (UTC) - 0:59:35 - train - INFO - step: 000466 - done (%): 93.2 - loss: 1.984 - lr: 7.6e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5568.9 - avg_words_per_second: 4351.3 - ETA: >2024-05-25 21:30:02 +2024-05-25 21:25:52 (UTC) - 0:59:41 - train - INFO - step: 000467 - done (%): 93.4 - loss: 1.292 - lr: 7.1e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5567.1 - avg_words_per_second: 4353.4 - ETA: >2024-05-25 21:30:00 +2024-05-25 21:25:58 (UTC) - 0:59:47 - train - INFO - step: 000468 - done (%): 93.6 - loss: 1.434 - lr: 6.7e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5567.1 - avg_words_per_second: 4355.4 - ETA: >2024-05-25 21:29:58 +2024-05-25 21:26:04 (UTC) - 0:59:53 - train - INFO - step: 000469 - done (%): 93.8 - loss: 1.580 - lr: 6.3e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5539.1 - avg_words_per_second: 4357.4 - ETA: >2024-05-25 21:29:57 +2024-05-25 21:26:09 (UTC) - 0:59:59 - train - INFO - step: 000470 - done (%): 94.0 - loss: 2.000 - lr: 5.9e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.1 - avg_words_per_second: 4359.4 - ETA: >2024-05-25 21:29:55 +2024-05-25 21:26:28 (UTC) - 1:00:17 - train - INFO - step: 000471 - done (%): 94.2 - loss: 1.639 - lr: 5.5e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 1804.3 - avg_words_per_second: 4346.3 - ETA: >2024-05-25 21:30:06 +2024-05-25 21:26:33 (UTC) - 1:00:23 - train - INFO - step: 000472 - done (%): 94.4 - loss: 1.678 - lr: 5.1e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5620.5 - avg_words_per_second: 4348.4 - ETA: >2024-05-25 21:30:04 +2024-05-25 21:26:39 (UTC) - 1:00:29 - train - INFO - step: 000473 - done (%): 94.6 - loss: 1.519 - lr: 4.8e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5605.5 - avg_words_per_second: 4350.5 - ETA: >2024-05-25 21:30:03 +2024-05-25 21:26:45 (UTC) - 1:00:34 - train - INFO - step: 000474 - done (%): 94.8 - loss: 1.470 - lr: 4.4e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5567.5 - avg_words_per_second: 4352.5 - ETA: >2024-05-25 21:30:01 +2024-05-25 21:26:51 (UTC) - 1:00:40 - train - INFO - step: 000475 - done (%): 95.0 - loss: 1.381 - lr: 4.1e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5584.5 - avg_words_per_second: 4354.5 - ETA: >2024-05-25 21:29:59 +2024-05-25 21:26:57 (UTC) - 1:00:46 - train - INFO - step: 000476 - done (%): 95.2 - loss: 0.867 - lr: 3.8e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.6 - avg_words_per_second: 4356.5 - ETA: >2024-05-25 21:29:57 +2024-05-25 21:27:03 (UTC) - 1:00:52 - train - INFO - step: 000477 - done (%): 95.4 - loss: 1.500 - lr: 3.5e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.3 - avg_words_per_second: 4358.5 - ETA: >2024-05-25 21:29:56 +2024-05-25 21:27:09 (UTC) - 1:00:58 - train - INFO - step: 000478 - done (%): 95.6 - loss: 1.657 - lr: 3.2e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5575.2 - avg_words_per_second: 4360.5 - ETA: >2024-05-25 21:29:54 +2024-05-25 21:27:15 (UTC) - 1:01:04 - train - INFO - step: 000479 - done (%): 95.8 - loss: 1.572 - lr: 2.9e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5571.7 - avg_words_per_second: 4362.5 - ETA: >2024-05-25 21:29:52 +2024-05-25 21:27:21 (UTC) - 1:01:10 - train - INFO - step: 000480 - done (%): 96.0 - loss: 1.540 - lr: 2.6e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.1 - avg_words_per_second: 4364.4 - ETA: >2024-05-25 21:29:51 +2024-05-25 21:27:26 (UTC) - 1:01:16 - train - INFO - step: 000481 - done (%): 96.2 - loss: 1.518 - lr: 2.4e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5576.8 - avg_words_per_second: 4366.4 - ETA: >2024-05-25 21:29:49 +2024-05-25 21:27:32 (UTC) - 1:01:22 - train - INFO - step: 000482 - done (%): 96.4 - loss: 1.756 - lr: 2.1e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.7 - avg_words_per_second: 4368.4 - ETA: >2024-05-25 21:29:47 +2024-05-25 21:27:38 (UTC) - 1:01:27 - train - INFO - step: 000483 - done (%): 96.6 - loss: 1.598 - lr: 1.9e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5563.8 - avg_words_per_second: 4370.3 - ETA: >2024-05-25 21:29:46 +2024-05-25 21:27:44 (UTC) - 1:01:33 - train - INFO - step: 000484 - done (%): 96.8 - loss: 1.527 - lr: 1.7e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5542.3 - avg_words_per_second: 4372.2 - ETA: >2024-05-25 21:29:44 +2024-05-25 21:27:50 (UTC) - 1:01:39 - train - INFO - step: 000485 - done (%): 97.0 - loss: 1.523 - lr: 1.5e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5566.4 - avg_words_per_second: 4374.1 - ETA: >2024-05-25 21:29:42 +2024-05-25 21:27:56 (UTC) - 1:01:45 - train - INFO - step: 000486 - done (%): 97.2 - loss: 0.878 - lr: 1.3e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5542.9 - avg_words_per_second: 4376.0 - ETA: >2024-05-25 21:29:41 +2024-05-25 21:28:02 (UTC) - 1:01:51 - train - INFO - step: 000487 - done (%): 97.4 - loss: 1.266 - lr: 1.1e-07 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5541.1 - avg_words_per_second: 4377.9 - ETA: >2024-05-25 21:29:39 +2024-05-25 21:28:08 (UTC) - 1:01:57 - train - INFO - step: 000488 - done (%): 97.6 - loss: 1.403 - lr: 9.5e-08 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5568.3 - avg_words_per_second: 4379.8 - ETA: >2024-05-25 21:29:37 +2024-05-25 21:28:14 (UTC) - 1:02:03 - train - INFO - step: 000489 - done (%): 97.8 - loss: 1.650 - lr: 8.0e-08 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.6 - avg_words_per_second: 4381.8 - ETA: >2024-05-25 21:29:36 +2024-05-25 21:28:19 (UTC) - 1:02:09 - train - INFO - step: 000490 - done (%): 98.0 - loss: 1.745 - lr: 6.6e-08 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5561.4 - avg_words_per_second: 4383.6 - ETA: >2024-05-25 21:29:34 +2024-05-25 21:28:25 (UTC) - 1:02:15 - train - INFO - step: 000491 - done (%): 98.2 - loss: 1.479 - lr: 5.3e-08 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5567.4 - avg_words_per_second: 4385.5 - ETA: >2024-05-25 21:29:33 +2024-05-25 21:28:31 (UTC) - 1:02:21 - train - INFO - step: 000492 - done (%): 98.4 - loss: 1.589 - lr: 4.2e-08 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5532.8 - avg_words_per_second: 4387.4 - ETA: >2024-05-25 21:29:31 +2024-05-25 21:28:37 (UTC) - 1:02:26 - train - INFO - step: 000493 - done (%): 98.6 - loss: 1.433 - lr: 3.2e-08 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5560.1 - avg_words_per_second: 4389.3 - ETA: >2024-05-25 21:29:29 +2024-05-25 21:28:43 (UTC) - 1:02:32 - train - INFO - step: 000494 - done (%): 98.8 - loss: 1.396 - lr: 2.4e-08 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5571.3 - avg_words_per_second: 4391.2 - ETA: >2024-05-25 21:29:28 +2024-05-25 21:28:49 (UTC) - 1:02:38 - train - INFO - step: 000495 - done (%): 99.0 - loss: 1.495 - lr: 1.7e-08 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.7 - avg_words_per_second: 4393.0 - ETA: >2024-05-25 21:29:26 +2024-05-25 21:28:55 (UTC) - 1:02:44 - train - INFO - step: 000496 - done (%): 99.2 - loss: 1.840 - lr: 1.1e-08 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5564.2 - avg_words_per_second: 4394.9 - ETA: >2024-05-25 21:29:25 +2024-05-25 21:29:01 (UTC) - 1:02:50 - train - INFO - step: 000497 - done (%): 99.4 - loss: 1.532 - lr: 6.1e-09 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5555.7 - avg_words_per_second: 4396.7 - ETA: >2024-05-25 21:29:23 +2024-05-25 21:29:07 (UTC) - 1:02:56 - train - INFO - step: 000498 - done (%): 99.6 - loss: 1.762 - lr: 2.9e-09 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5565.6 - avg_words_per_second: 4398.6 - ETA: >2024-05-25 21:29:22 +2024-05-25 21:29:13 (UTC) - 1:03:02 - train - INFO - step: 000499 - done (%): 99.8 - loss: 1.654 - lr: 9.0e-10 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5559.1 - avg_words_per_second: 4400.4 - ETA: >2024-05-25 21:29:20 +2024-05-25 21:29:18 (UTC) - 1:03:08 - train - INFO - step: 000500 - done (%): 100.0 - loss: 1.423 - lr: 2.4e-10 - peak_alloc_mem (GB): 47.0 - alloc_mem (GB): 20.1 - words_per_second: 5570.5 - avg_words_per_second: 4402.3 - ETA: >2024-05-25 21:29:18 +2024-05-25 21:29:18 (UTC) - 1:03:08 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runs2/checkpoints/checkpoint_000500/consolidated using tmp name: tmp.consolidated +2024-05-25 21:29:33 (UTC) - 1:03:22 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runs2/checkpoints/checkpoint_000500/consolidated for step: 500 +2024-05-25 21:29:34 (UTC) - 1:03:23 - checkpointing - INFO - Deleted ckpt: /root/mistral-finetune/runs2/checkpoints/checkpoint_000200 +2024-05-25 21:29:34 (UTC) - 1:03:23 - checkpointing - INFO - Done deleting checkpoints /root/mistral-finetune/runs2/checkpoints/checkpoint_000200 +2024-05-25 21:29:34 (UTC) - 1:03:23 - checkpointing - INFO - Done! +2024-05-25 21:29:34 (UTC) - 1:03:23 - train - INFO - done! +2024-05-25 21:29:34 (UTC) - 1:03:23 - utils - INFO - Closing: eval_logger \ No newline at end of file diff --git a/runs2/wandb/run-20240525_202613-sapihyp4/files/requirements.txt b/runs2/wandb/run-20240525_202613-sapihyp4/files/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..f173be0be357b3fd62b7aba8d8c38a23b90cdc07 --- /dev/null +++ b/runs2/wandb/run-20240525_202613-sapihyp4/files/requirements.txt @@ -0,0 +1,67 @@ +GitPython==3.1.43 +Jinja2==3.1.4 +Markdown==3.6 +MarkupSafe==2.1.5 +PyYAML==6.0.1 +Werkzeug==3.0.3 +absl-py==2.1.0 +annotated-types==0.7.0 +attrs==23.2.0 +certifi==2024.2.2 +charset-normalizer==3.3.2 +click==8.1.7 +docker-pycreds==0.4.0 +docstring_parser==0.16 +filelock==3.14.0 +fire==0.6.0 +fsspec==2024.5.0 +gitdb==4.0.11 +grpcio==1.64.0 +idna==3.7 +jsonschema-specifications==2023.12.1 +jsonschema==4.21.1 +mistral_common==1.1.0 +mpmath==1.3.0 +networkx==3.3 +numpy==1.26.4 +nvidia-cublas-cu12==12.1.3.1 +nvidia-cuda-cupti-cu12==12.1.105 +nvidia-cuda-nvrtc-cu12==12.1.105 +nvidia-cuda-runtime-cu12==12.1.105 +nvidia-cudnn-cu12==8.9.2.26 +nvidia-cufft-cu12==11.0.2.54 +nvidia-curand-cu12==10.3.2.106 +nvidia-cusolver-cu12==11.4.5.107 +nvidia-cusparse-cu12==12.1.0.106 +nvidia-nccl-cu12==2.19.3 +nvidia-nvjitlink-cu12==12.5.40 +nvidia-nvtx-cu12==12.1.105 +pip==24.0 +platformdirs==4.2.2 +protobuf==4.25.3 +psutil==5.9.8 +pydantic==2.6.1 +pydantic_core==2.16.2 +referencing==0.35.1 +requests==2.32.2 +rpds-py==0.18.1 +safetensors==0.4.3 +sentencepiece==0.1.99 +sentry-sdk==2.3.1 +setproctitle==1.3.3 +setuptools==69.5.1 +simple_parsing==0.1.5 +six==1.16.0 +smmap==5.0.1 +sympy==1.12 +tensorboard-data-server==0.7.2 +tensorboard==2.16.2 +termcolor==2.4.0 +torch==2.2.0 +tqdm==4.66.4 +triton==2.2.0 +typing_extensions==4.12.0 +urllib3==2.2.1 +wandb==0.17.0 +wheel==0.43.0 +xformers==0.0.24 \ No newline at end of file diff --git a/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-metadata.json b/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..d9d874be78bf6b4c921420e8dde367803b143cb2 --- /dev/null +++ b/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-metadata.json @@ -0,0 +1,169 @@ +{ + "os": "Linux-5.15.0-102-generic-x86_64-with-glibc2.35", + "python": "3.10.14", + "heartbeatAt": "2024-05-25T20:26:14.147426", + "startedAt": "2024-05-25T20:26:13.700754", + "docker": null, + "cuda": null, + "args": [ + "example/7B.yaml" + ], + "state": "running", + "program": "-m train", + "codePathLocal": null, + "git": { + "remote": "https://github.com/mistralai/mistral-finetune.git", + "commit": "cb892f012ef940bc741dd3b043bc1d06f0cf6085" + }, + "email": "clement.castellon@gmail.com", + "root": "/root/mistral-finetune", + "host": "scw-tender-archimedes", + "username": "root", + "executable": "/root/miniconda/envs/chemistralpy310/bin/python", + "cpu_count": 24, + "cpu_count_logical": 24, + "cpu_freq": { + "current": 2699.9959999999996, + "min": 0.0, + "max": 0.0 + }, + "cpu_freq_per_core": [ + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + } + ], + "disk": { + "/": { + "total": 902.4293403625488, + "used": 150.20981216430664 + } + }, + "gpu": "NVIDIA H100 PCIe", + "gpu_count": 1, + "gpu_devices": [ + { + "name": "NVIDIA H100 PCIe", + "memory_total": 85520809984 + } + ], + "memory": { + "total": 235.9408187866211 + } +} diff --git a/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json b/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json new file mode 100644 index 0000000000000000000000000000000000000000..b9bf430896b256cb34c97f31dfa6bddb5a1e5cc3 --- /dev/null +++ b/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json @@ -0,0 +1 @@ +{"train/lr": 2.4e-10, "train/loss": 1.4225248098373413, "train/percent_done": 100.0, "train/peak_allocated_mem": 46.97587060928345, "train/allocated_mem": 20.138556957244873, "train/wps": 5570.524207261232, "train/avg_wps": 4402.290443341627, "train/eta_in_seconds": 0.0, "_timestamp": 1716672558.906064, "_runtime": 3785.2030460834503, "_step": 500, "_wandb": {"runtime": 3800}} \ No newline at end of file diff --git a/runs2/wandb/run-20240525_202613-sapihyp4/logs/debug-internal.log b/runs2/wandb/run-20240525_202613-sapihyp4/logs/debug-internal.log new file mode 100644 index 0000000000000000000000000000000000000000..feca48369df2ba236aa96ccfa9c13974405739b8 --- /dev/null +++ b/runs2/wandb/run-20240525_202613-sapihyp4/logs/debug-internal.log @@ -0,0 +1,4498 @@ +2024-05-25 20:26:13,703 INFO StreamThr :33547 [internal.py:wandb_internal():85] W&B internal server running at pid: 33547, started at: 2024-05-25 20:26:13.703173 +2024-05-25 20:26:13,704 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status +2024-05-25 20:26:13,706 INFO WriterThread:33547 [datastore.py:open_for_write():87] open: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/run-sapihyp4.wandb +2024-05-25 20:26:13,707 DEBUG SenderThread:33547 [sender.py:send():378] send: header +2024-05-25 20:26:13,707 DEBUG SenderThread:33547 [sender.py:send():378] send: run +2024-05-25 20:26:14,049 INFO SenderThread:33547 [dir_watcher.py:__init__():211] watching files in: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files +2024-05-25 20:26:14,049 INFO SenderThread:33547 [sender.py:_start_run_threads():1123] run started: sapihyp4 with start time 1716668773.703018 +2024-05-25 20:26:14,054 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: check_version +2024-05-25 20:26:14,054 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: check_version +2024-05-25 20:26:14,130 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: run_start +2024-05-25 20:26:14,135 DEBUG HandlerThread:33547 [system_info.py:__init__():26] System info init +2024-05-25 20:26:14,135 DEBUG HandlerThread:33547 [system_info.py:__init__():41] System info init done +2024-05-25 20:26:14,135 INFO HandlerThread:33547 [system_monitor.py:start():194] Starting system monitor +2024-05-25 20:26:14,135 INFO SystemMonitor:33547 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-05-25 20:26:14,135 INFO HandlerThread:33547 [system_monitor.py:probe():214] Collecting system info +2024-05-25 20:26:14,136 INFO SystemMonitor:33547 [interfaces.py:start():188] Started cpu monitoring +2024-05-25 20:26:14,137 INFO SystemMonitor:33547 [interfaces.py:start():188] Started disk monitoring +2024-05-25 20:26:14,137 INFO SystemMonitor:33547 [interfaces.py:start():188] Started gpu monitoring +2024-05-25 20:26:14,138 INFO SystemMonitor:33547 [interfaces.py:start():188] Started memory monitoring +2024-05-25 20:26:14,138 INFO SystemMonitor:33547 [interfaces.py:start():188] Started network monitoring +2024-05-25 20:26:14,147 DEBUG HandlerThread:33547 [system_info.py:probe():150] Probing system +2024-05-25 20:26:14,148 DEBUG HandlerThread:33547 [system_info.py:_probe_git():135] Probing git +2024-05-25 20:26:14,151 DEBUG HandlerThread:33547 [system_info.py:_probe_git():143] Probing git done +2024-05-25 20:26:14,151 DEBUG HandlerThread:33547 [system_info.py:probe():198] Probing system done +2024-05-25 20:26:14,151 DEBUG HandlerThread:33547 [system_monitor.py:probe():223] {'os': 'Linux-5.15.0-102-generic-x86_64-with-glibc2.35', 'python': '3.10.14', 'heartbeatAt': '2024-05-25T20:26:14.147426', 'startedAt': '2024-05-25T20:26:13.700754', 'docker': None, 'cuda': None, 'args': ('example/7B.yaml',), 'state': 'running', 'program': '-m train', 'codePathLocal': None, 'git': {'remote': 'https://github.com/mistralai/mistral-finetune.git', 'commit': 'cb892f012ef940bc741dd3b043bc1d06f0cf6085'}, 'email': 'clement.castellon@gmail.com', 'root': '/root/mistral-finetune', 'host': 'scw-tender-archimedes', 'username': 'root', 'executable': '/root/miniconda/envs/chemistralpy310/bin/python', 'cpu_count': 24, 'cpu_count_logical': 24, 'cpu_freq': {'current': 2699.9959999999996, 'min': 0.0, 'max': 0.0}, 'cpu_freq_per_core': [{'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}], 'disk': {'/': {'total': 902.4293403625488, 'used': 150.20981216430664}}, 'gpu': 'NVIDIA H100 PCIe', 'gpu_count': 1, 'gpu_devices': [{'name': 'NVIDIA H100 PCIe', 'memory_total': 85520809984}], 'memory': {'total': 235.9408187866211}} +2024-05-25 20:26:14,151 INFO HandlerThread:33547 [system_monitor.py:probe():224] Finished collecting system info +2024-05-25 20:26:14,151 INFO HandlerThread:33547 [system_monitor.py:probe():227] Publishing system info +2024-05-25 20:26:14,151 DEBUG HandlerThread:33547 [system_info.py:_save_conda():207] Saving list of conda packages installed into the current environment +2024-05-25 20:26:15,050 INFO Thread-12 :33547 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/conda-environment.yaml +2024-05-25 20:26:15,117 DEBUG HandlerThread:33547 [system_info.py:_save_conda():222] Saving conda packages done +2024-05-25 20:26:15,117 INFO HandlerThread:33547 [system_monitor.py:probe():229] Finished publishing system info +2024-05-25 20:26:15,120 DEBUG SenderThread:33547 [sender.py:send():378] send: files +2024-05-25 20:26:15,120 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-metadata.json with policy now +2024-05-25 20:26:15,147 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: python_packages +2024-05-25 20:26:15,147 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: python_packages +2024-05-25 20:26:15,147 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:26:15,147 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:26:15,340 DEBUG SenderThread:33547 [sender.py:send():378] send: telemetry +2024-05-25 20:26:15,598 INFO wandb-upload_0:33547 [upload_job.py:push():130] Uploaded file /tmp/tmp1tdz824awandb/653o9vjt-wandb-metadata.json +2024-05-25 20:26:16,050 INFO Thread-12 :33547 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/requirements.txt +2024-05-25 20:26:16,050 INFO Thread-12 :33547 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:26:16,050 INFO Thread-12 :33547 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-metadata.json +2024-05-25 20:26:18,050 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:26:19,275 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:26:24,276 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:26:29,277 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:26:30,188 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:26:30,189 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:26:34,415 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:26:39,416 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:26:44,418 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:26:45,057 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/config.yaml +2024-05-25 20:26:45,183 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:26:45,184 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:26:50,402 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:26:55,403 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:27:00,173 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:27:00,174 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:27:00,406 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:27:05,406 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:27:10,407 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:27:14,139 DEBUG SystemMonitor:33547 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-05-25 20:27:14,140 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:27:15,189 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:27:15,189 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:27:16,347 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:27:21,348 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:27:26,349 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:27:30,210 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:27:30,211 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:27:32,346 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:27:37,347 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:27:42,348 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:27:44,140 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:27:45,211 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:27:45,211 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:27:47,369 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:27:52,369 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:27:57,370 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:28:00,222 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:28:00,222 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:28:02,450 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:28:07,451 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:28:12,451 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:28:14,141 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:28:15,263 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:28:15,263 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:28:17,476 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:28:22,477 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:28:27,478 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:28:30,222 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:28:30,223 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:28:33,464 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:28:38,465 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:28:43,466 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:28:44,141 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:28:45,243 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:28:45,244 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:28:49,425 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:28:54,426 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:28:59,426 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:29:00,249 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:29:00,250 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:29:04,454 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:29:09,455 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:29:14,142 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:29:15,142 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:29:15,229 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:29:15,229 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:29:20,459 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:29:25,460 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:29:30,239 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:29:30,239 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:29:31,396 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:29:36,397 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:29:41,397 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:29:44,142 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:29:45,272 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:29:45,272 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:29:46,448 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:29:51,449 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:29:56,450 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:30:00,315 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:30:00,315 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:30:01,462 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:30:06,463 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:30:11,464 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:30:14,142 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:30:15,249 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:30:15,250 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:30:16,473 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:30:21,474 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:30:26,474 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:30:30,260 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:30:30,260 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:30:32,395 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:30:37,395 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:30:42,396 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:30:44,143 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:30:45,276 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:30:45,277 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:30:47,427 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:30:52,428 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:30:57,428 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:31:00,314 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:31:00,314 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:31:02,519 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:31:07,520 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:31:12,521 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:31:14,144 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:31:15,271 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:31:15,271 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:31:18,513 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:31:23,513 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:31:28,514 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:31:30,277 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:31:30,277 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:31:34,452 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:31:39,453 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:31:44,144 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:31:45,145 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:31:45,277 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:31:45,277 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:31:50,503 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:31:55,503 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:32:00,303 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:32:00,303 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:32:01,493 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:32:06,494 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:32:11,495 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:32:14,144 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:32:15,308 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:32:15,309 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:32:17,488 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:32:22,488 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:32:27,489 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:32:32,490 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:32:32,584 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:32:32,584 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:32:37,730 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:32:42,731 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:32:44,145 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:32:47,578 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:32:47,579 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:32:47,756 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:32:52,757 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:32:57,757 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:33:02,610 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:33:02,611 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:33:03,748 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:33:08,749 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:33:13,749 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:33:14,146 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:33:17,589 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:33:17,589 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:33:18,797 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:33:23,798 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:33:28,798 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:33:32,590 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:33:32,590 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:33:34,764 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:33:39,765 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:33:44,146 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:33:45,147 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:33:47,610 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:33:47,610 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:33:50,764 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:33:55,764 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:34:00,765 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:34:02,623 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:34:02,623 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:34:05,777 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:34:10,778 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:34:14,147 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:34:16,147 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:34:17,605 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:34:17,606 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:34:21,845 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:34:26,845 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:34:31,846 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:34:32,611 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:34:32,611 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:34:36,855 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:34:41,856 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:34:44,147 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:34:47,148 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:34:47,611 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:34:47,611 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:34:52,823 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:34:57,824 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:35:02,616 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:35:02,617 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:35:03,763 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:35:08,764 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:35:13,765 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:35:14,148 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:35:17,622 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:35:17,622 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:35:18,866 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:35:23,867 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:35:28,867 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:35:32,645 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:35:32,645 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:35:34,844 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:35:39,844 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:35:44,148 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:35:45,149 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:35:47,642 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:35:47,643 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:35:50,862 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:35:55,862 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:36:00,863 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:36:02,643 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:36:02,643 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:36:05,864 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:36:10,865 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:36:14,149 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:36:16,149 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:36:17,663 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:36:17,663 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:36:21,866 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:36:26,866 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:36:31,867 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:36:32,680 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:36:32,680 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:36:36,868 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:36:41,869 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:36:44,149 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:36:47,150 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:36:47,659 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:36:47,660 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:36:52,841 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:36:57,842 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:37:02,732 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:37:02,732 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:37:02,936 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:37:07,937 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:37:12,938 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:37:14,153 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:37:17,686 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:37:17,686 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:37:18,925 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:37:23,926 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:37:28,927 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:37:32,726 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:37:32,727 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:37:34,921 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:37:39,922 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:37:44,150 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:37:45,151 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:37:47,690 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:37:47,691 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:37:50,828 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:37:55,829 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:38:00,830 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:38:02,690 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:38:02,691 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:38:05,832 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:38:10,833 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:38:14,151 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:38:16,152 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:38:17,690 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:38:17,691 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:38:21,827 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:38:27,797 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:38:28,229 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:38:32,675 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:38:32,675 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:38:32,849 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:38:33,049 DEBUG SenderThread:33547 [sender.py:send():378] send: telemetry +2024-05-25 20:38:33,049 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:38:34,231 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:38:38,050 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:38:38,802 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:38:38,803 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:38:38,804 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:38:38,804 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:38:39,232 INFO Thread-12 :33547 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:38:40,232 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:38:43,807 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:38:44,151 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:38:44,233 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/config.yaml +2024-05-25 20:38:44,598 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:38:44,599 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:38:44,599 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:38:44,599 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:38:45,234 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:38:46,234 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:38:47,675 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:38:47,676 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:38:49,910 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:38:50,411 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:38:50,411 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:38:50,411 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:38:50,412 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:38:51,235 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:38:52,236 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:38:55,412 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:38:56,232 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:38:56,232 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:38:56,233 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:38:56,233 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:38:56,237 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:38:58,237 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:39:01,234 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:39:02,070 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:39:02,070 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:39:02,071 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:39:02,071 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:39:02,238 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:39:02,676 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:39:02,676 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:39:04,239 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:39:06,909 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:39:07,919 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:39:07,920 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:39:07,920 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:39:07,920 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:39:08,240 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:39:10,240 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:39:11,921 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:39:13,772 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:39:13,773 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:39:13,773 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:39:13,773 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:39:14,152 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:39:14,241 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:39:17,153 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:39:17,243 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:39:17,676 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:39:17,676 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:39:19,639 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:39:19,640 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:39:19,640 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:39:19,640 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:39:20,244 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:39:21,244 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:39:22,641 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:39:25,512 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:39:25,513 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:39:25,513 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:39:25,514 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:39:26,245 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:39:27,246 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:39:28,514 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:39:31,414 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:39:31,414 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:39:31,415 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:39:31,415 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:39:32,247 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:39:32,676 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:39:32,676 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:39:33,247 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:39:33,852 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:39:37,311 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:39:37,312 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:39:37,312 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:39:37,312 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:39:38,248 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:39:39,249 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:39:39,313 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:39:43,196 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:39:43,197 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:39:43,197 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:39:43,197 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:39:43,250 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:39:44,152 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:39:45,153 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:39:45,250 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:39:47,676 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:39:47,676 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:39:49,077 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:39:49,078 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:39:49,078 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:39:49,078 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:39:49,251 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:39:51,079 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:39:51,252 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:39:54,975 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:39:54,975 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:39:54,975 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:39:54,976 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:39:55,253 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:39:56,976 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:39:57,253 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:40:00,873 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:40:00,874 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:40:00,874 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:40:00,875 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:40:01,254 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:40:02,676 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:40:02,676 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:40:02,904 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:40:03,255 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:40:06,774 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:40:06,775 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:40:06,775 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:40:06,775 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:40:07,256 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:40:08,776 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:40:09,256 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:40:12,674 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:40:12,675 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:40:12,675 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:40:12,676 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:40:13,257 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:40:14,153 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:40:14,153 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:40:15,258 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:40:17,676 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:40:17,676 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:40:18,575 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:40:18,575 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:40:18,575 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:40:18,575 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:40:19,259 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:40:19,576 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:40:21,259 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:40:24,474 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:40:24,474 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:40:24,474 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:40:24,475 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:40:25,260 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:40:25,475 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:40:27,261 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:40:30,367 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:40:30,368 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:40:30,368 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:40:30,369 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:40:31,262 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:40:31,369 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:40:32,676 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:40:32,676 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:40:33,262 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:40:36,262 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:40:36,263 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:40:36,263 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:40:36,263 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:40:36,264 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:40:37,264 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:40:39,265 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:40:42,161 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:40:42,162 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:40:42,162 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:40:42,162 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:40:42,266 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:40:43,163 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:40:44,153 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:40:45,266 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:40:47,676 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:40:47,677 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:40:48,073 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:40:48,074 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:40:48,074 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:40:48,075 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:40:48,267 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:40:49,075 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:40:51,268 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:40:53,966 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:40:53,966 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:40:53,966 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:40:53,967 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:40:54,269 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:40:54,967 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:40:57,270 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:40:59,859 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:40:59,860 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:40:59,860 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:40:59,860 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:41:00,271 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:41:00,861 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:41:01,272 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:41:02,676 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:41:02,677 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:41:05,766 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:41:05,766 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:41:05,766 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:41:05,767 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:41:06,273 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:41:06,767 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:41:07,273 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:41:11,660 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:41:11,661 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:41:11,661 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:41:11,662 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:41:12,275 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:41:12,662 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:41:13,275 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:41:14,158 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:41:17,561 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:41:17,562 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:41:17,562 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:41:17,562 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:41:17,676 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:41:17,677 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:41:17,797 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:41:18,276 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:41:19,277 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:41:22,798 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:41:23,463 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:41:23,464 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:41:23,464 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:41:23,465 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:41:24,278 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:41:25,278 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:41:28,466 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:41:29,360 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:41:29,361 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:41:29,361 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:41:29,362 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:41:30,279 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:41:31,280 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:41:32,676 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:41:32,677 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:41:33,896 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:41:35,263 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:41:35,264 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:41:35,264 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:41:35,264 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:41:35,281 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:41:37,281 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:41:39,265 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:41:41,170 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:41:41,171 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:41:41,171 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:41:41,171 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:41:41,282 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:41:43,283 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:41:44,154 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:41:45,155 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:41:47,078 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:41:47,078 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:41:47,079 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:41:47,080 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:41:47,284 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:41:47,677 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:41:47,677 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:41:49,285 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:41:50,866 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:41:52,978 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:41:52,979 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:41:52,979 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:41:52,979 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:41:53,286 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:41:55,287 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:41:55,980 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:41:58,876 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:41:58,877 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:41:58,877 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:41:58,877 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:41:59,288 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:42:01,288 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:42:01,878 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:42:02,677 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:42:02,677 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:42:04,774 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:42:04,775 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:42:04,775 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:42:04,775 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:42:05,289 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:42:07,290 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:42:07,776 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:42:10,674 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:42:10,675 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:42:10,675 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:42:10,675 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:42:11,291 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:42:13,292 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:42:13,676 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:42:14,155 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:42:16,585 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:42:16,585 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:42:16,586 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:42:16,586 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:42:17,293 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:42:17,677 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:42:17,677 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:42:18,873 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:42:19,294 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:42:22,477 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:42:22,478 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:42:22,478 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:42:22,479 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:42:23,295 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:42:24,479 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:42:25,295 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:42:28,399 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:42:28,400 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:42:28,400 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:42:28,401 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:42:29,297 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:42:30,401 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:42:31,297 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:42:32,677 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:42:32,677 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:42:34,315 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:42:34,316 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:42:34,316 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:42:34,316 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:42:35,298 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:42:36,317 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:42:37,299 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:42:40,205 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:42:40,206 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:42:40,206 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:42:40,206 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:42:40,300 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:42:42,207 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:42:43,301 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:42:44,155 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:42:46,099 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:42:46,099 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:42:46,100 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:42:46,100 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:42:46,302 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:42:47,677 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:42:47,677 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:42:47,849 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:42:49,303 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:42:52,003 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:42:52,004 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:42:52,004 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:42:52,004 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:42:52,304 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:42:53,005 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:42:53,304 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:42:57,896 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:42:57,897 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:42:57,897 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:42:57,897 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:42:58,306 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:42:58,898 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:42:59,306 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:43:02,677 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:43:02,677 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:43:03,798 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:43:03,798 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:43:03,798 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:43:03,799 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:43:04,307 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:43:04,799 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:43:05,308 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:43:09,699 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:43:09,699 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:43:09,700 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:43:09,700 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:43:10,309 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:43:10,700 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:43:11,310 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:43:14,156 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:43:15,605 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:43:15,606 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:43:15,606 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:43:15,607 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:43:16,311 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:43:16,607 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:43:17,311 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:43:17,677 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:43:17,677 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:43:21,526 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:43:21,526 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:43:21,527 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:43:21,528 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:43:22,313 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:43:22,528 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:43:23,313 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:43:27,433 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:43:27,434 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:43:27,434 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:43:27,434 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:43:28,315 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:43:28,434 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:43:29,315 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:43:32,677 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:43:32,678 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:43:33,338 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:43:33,339 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:43:33,339 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:43:33,339 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:43:34,316 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:43:34,340 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:43:35,317 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:43:39,238 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:43:39,239 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:43:39,239 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:43:39,239 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:43:39,318 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:43:40,240 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:43:41,319 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:43:44,156 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:43:45,164 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:43:45,164 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:43:45,165 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:43:45,165 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:43:45,320 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:43:46,165 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:43:47,321 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:43:47,677 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:43:47,678 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:43:51,057 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:43:51,058 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:43:51,058 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:43:51,058 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:43:51,322 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:43:52,059 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:43:53,322 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:43:56,977 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:43:56,978 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:43:56,978 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:43:56,978 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:43:57,324 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:43:57,979 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:43:59,324 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:44:02,677 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:44:02,678 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:44:02,879 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:44:02,879 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:44:02,880 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:44:02,880 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:44:03,325 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:44:03,880 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:44:05,326 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:44:08,798 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:44:08,799 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:44:08,799 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:44:08,799 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:44:09,327 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:44:09,799 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:44:11,328 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:44:14,157 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:44:14,700 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:44:14,700 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:44:14,701 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:44:14,701 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:44:15,329 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:44:15,701 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:44:17,330 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:44:17,678 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:44:17,678 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:44:20,605 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:44:20,610 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:44:20,610 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:44:20,610 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:44:21,331 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:44:21,611 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:44:23,331 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:44:26,516 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:44:26,516 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:44:26,517 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:44:26,517 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:44:27,333 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:44:27,517 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:44:29,333 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:44:32,436 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:44:32,437 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:44:32,437 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:44:32,437 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:44:32,678 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:44:32,678 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:44:32,899 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:44:33,335 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:44:35,335 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:44:37,900 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:44:38,335 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:44:38,336 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:44:38,336 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:44:38,337 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:44:38,337 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:44:41,338 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:44:43,338 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:44:44,157 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:44:44,243 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:44:44,243 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:44:44,243 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:44:44,244 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:44:44,339 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:44:47,340 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:44:47,678 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:44:47,678 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:44:48,871 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:44:50,143 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:44:50,144 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:44:50,144 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:44:50,144 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:44:50,341 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:44:51,341 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:44:54,145 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:44:56,045 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:44:56,045 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:44:56,046 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:44:56,047 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:44:56,342 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:44:57,343 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:45:00,047 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:45:01,959 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:45:01,960 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:45:01,960 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:45:01,960 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:45:02,344 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:45:02,678 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:45:02,678 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:45:03,344 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:45:05,871 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:45:07,862 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:45:07,862 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:45:07,863 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:45:07,863 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:45:08,345 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:45:09,346 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:45:11,864 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:45:13,773 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:45:13,774 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:45:13,774 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:45:13,775 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:45:14,158 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:45:14,347 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:45:15,347 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:45:17,159 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:45:17,678 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:45:17,678 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:45:19,674 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:45:19,674 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:45:19,674 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:45:19,675 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:45:20,349 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:45:21,349 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:45:22,675 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:45:25,576 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:45:25,577 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:45:25,577 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:45:25,577 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:45:26,350 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:45:27,351 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:45:28,578 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:45:31,486 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:45:31,487 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:45:31,487 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:45:31,487 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:45:32,352 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:45:32,678 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:45:32,678 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:45:33,352 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:45:33,866 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:45:37,382 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:45:37,383 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:45:37,383 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:45:37,383 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:45:38,354 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:45:39,354 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:45:39,384 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:45:43,306 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:45:43,307 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:45:43,307 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:45:43,307 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:45:43,355 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:45:44,159 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:45:45,159 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:45:45,356 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:45:47,678 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:45:47,679 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:45:49,194 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:45:49,194 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:45:49,195 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:45:49,195 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:45:49,357 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:45:50,195 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:45:51,357 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:45:55,085 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:45:55,086 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:45:55,086 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:45:55,086 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:45:55,358 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:45:56,087 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:45:57,359 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:46:00,985 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:46:00,986 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:46:00,986 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:46:00,986 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:46:01,360 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:46:01,987 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:46:02,678 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:46:02,679 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:46:03,360 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:46:06,886 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:46:06,887 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:46:06,887 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:46:06,887 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:46:07,361 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:46:07,888 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:46:09,362 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:46:12,803 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:46:12,804 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:46:12,804 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:46:12,804 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:46:13,363 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:46:13,805 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:46:14,159 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:46:15,363 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:46:17,679 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:46:17,679 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:46:18,694 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:46:18,695 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:46:18,695 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:46:18,695 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:46:19,364 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:46:19,696 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:46:21,365 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:46:24,593 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:46:24,593 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:46:24,594 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:46:24,594 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:46:25,366 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:46:25,594 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:46:27,366 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:46:30,495 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:46:30,496 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:46:30,496 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:46:30,497 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:46:31,368 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:46:31,497 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:46:32,679 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:46:32,679 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:46:33,368 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:46:36,391 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:46:36,391 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:46:36,392 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:46:36,392 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:46:37,369 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:46:37,392 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:46:39,370 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:46:42,287 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:46:42,287 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:46:42,287 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:46:42,288 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:46:42,370 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:46:43,288 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:46:43,371 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:46:44,160 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:46:47,679 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:46:47,679 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:46:48,179 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:46:48,180 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:46:48,180 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:46:48,180 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:46:48,372 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:46:49,181 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:46:49,372 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:46:54,074 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:46:54,075 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:46:54,075 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:46:54,076 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:46:54,374 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:46:55,076 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:46:55,374 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:46:59,969 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:46:59,970 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:46:59,970 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:46:59,971 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:47:00,375 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:47:00,971 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:47:01,375 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:47:02,679 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:47:02,679 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:47:05,864 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:47:05,865 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:47:05,865 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:47:05,865 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:47:06,377 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:47:06,866 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:47:07,377 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:47:11,763 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:47:11,763 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:47:11,764 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:47:11,764 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:47:12,378 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:47:12,764 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:47:13,378 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:47:14,160 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:47:17,686 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:47:17,686 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:47:17,686 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:47:17,687 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:47:17,687 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:47:17,687 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:47:17,879 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:47:18,380 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:47:19,380 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:47:22,880 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:47:23,575 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:47:23,576 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:47:23,576 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:47:23,577 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:47:24,381 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:47:25,382 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:47:28,577 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:47:29,507 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:47:29,508 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:47:29,508 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:47:29,508 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:47:30,383 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:47:31,383 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:47:32,686 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:47:32,686 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:47:33,914 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:47:35,398 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:47:35,402 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:47:35,403 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:47:35,403 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:47:36,384 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:47:37,385 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:47:39,404 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:47:41,323 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:47:41,324 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:47:41,324 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:47:41,324 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:47:41,386 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:47:43,386 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:47:44,161 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:47:45,161 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:47:47,237 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:47:47,238 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:47:47,238 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:47:47,238 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:47:47,387 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:47:47,686 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:47:47,686 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:47:49,388 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:47:50,844 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:47:53,139 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:47:53,140 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:47:53,140 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:47:53,140 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:47:53,389 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:47:55,389 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:47:56,141 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:47:59,032 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:47:59,033 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:47:59,033 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:47:59,033 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:47:59,390 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:48:01,391 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:48:02,034 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:48:02,686 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:48:02,687 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:48:04,945 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:48:04,945 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:48:04,946 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:48:04,946 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:48:05,392 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:48:07,392 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:48:07,946 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:48:10,855 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:48:10,856 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:48:10,856 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:48:10,857 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:48:11,393 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:48:13,394 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:48:13,857 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:48:14,161 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:48:16,747 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:48:16,748 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:48:16,748 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:48:16,748 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:48:17,395 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:48:17,686 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:48:17,687 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:48:18,905 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:48:19,396 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:48:23,906 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:48:28,907 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:48:32,686 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:48:32,687 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:48:33,399 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:48:34,846 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:48:37,367 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:48:37,368 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:48:37,368 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:48:37,400 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:48:37,509 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:48:39,401 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:48:40,510 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:48:43,226 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:48:43,227 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:48:43,228 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:48:43,247 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:48:43,402 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:48:44,162 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:48:45,402 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:48:46,162 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:48:47,687 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:48:47,687 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:48:49,076 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:48:49,077 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:48:49,077 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:48:49,077 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:48:49,403 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:48:51,404 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:48:52,078 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:48:54,947 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:48:54,948 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:48:54,948 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:48:54,949 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:48:55,404 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:48:57,405 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:48:57,949 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:49:00,817 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:49:00,817 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:49:00,817 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:49:00,818 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:49:01,406 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:49:02,687 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:49:02,687 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:49:03,407 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:49:03,878 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:49:06,689 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:49:06,690 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:49:06,690 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:49:06,690 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:49:07,407 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:49:09,408 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:49:09,691 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:49:14,162 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:49:15,163 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:49:17,891 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:49:17,892 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:49:21,107 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:49:22,274 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:49:22,275 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:49:22,275 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:49:22,275 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:49:22,411 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:49:23,411 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:49:26,276 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:49:28,084 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:49:28,085 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:49:28,085 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:49:28,085 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:49:28,413 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:49:29,413 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:49:32,086 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:49:32,891 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:49:32,891 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:49:33,970 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:49:33,970 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:49:33,970 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:49:33,971 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:49:34,414 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:49:35,414 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:49:37,972 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:49:39,848 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:49:39,849 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:49:39,849 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:49:39,849 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:49:40,415 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:49:41,416 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:49:43,850 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:49:44,163 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:49:45,727 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:49:45,728 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:49:45,728 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:49:45,729 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:49:46,417 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:49:47,417 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:49:47,891 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:49:47,892 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:49:49,121 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:49:51,601 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:49:51,601 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:49:51,602 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:49:51,602 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:49:52,418 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:49:53,419 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:49:54,603 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:49:57,499 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:49:57,500 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:49:57,500 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:49:57,500 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:49:58,420 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:49:59,420 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:50:00,501 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:50:02,891 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:50:02,892 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:50:03,434 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:50:03,434 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:50:03,435 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:50:03,435 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:50:04,421 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:50:05,421 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:50:06,436 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:50:09,268 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:50:09,268 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:50:09,268 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:50:09,269 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:50:09,422 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:50:11,423 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:50:12,269 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:50:14,163 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:50:15,162 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:50:15,163 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:50:15,163 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:50:15,163 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:50:15,424 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:50:17,424 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:50:17,891 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:50:17,891 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:50:17,892 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:50:21,126 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:50:21,127 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:50:21,127 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:50:21,127 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:50:21,425 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:50:23,127 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:50:23,425 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:50:26,983 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:50:26,984 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:50:26,984 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:50:26,984 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:50:27,426 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:50:28,985 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:50:29,427 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:50:32,882 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:50:32,883 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:50:32,883 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:50:32,883 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:50:32,893 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:50:32,893 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:50:33,428 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:50:34,058 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:50:35,428 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:50:38,826 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:50:38,827 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:50:38,827 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:50:38,827 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:50:39,430 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:50:39,828 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:50:41,431 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:50:44,164 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:50:44,679 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:50:44,679 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:50:44,679 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:50:44,680 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:50:45,432 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:50:45,680 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:50:47,432 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:50:47,892 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:50:47,893 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:50:50,630 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:50:50,631 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:50:50,631 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:50:50,631 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:50:51,433 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:50:51,434 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:50:51,632 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:50:56,489 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:50:56,492 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:50:56,492 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:50:56,492 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:50:57,435 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:50:57,435 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:50:57,493 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:51:02,386 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:51:02,386 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:51:02,387 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:51:02,387 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:51:02,436 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:51:02,892 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:51:02,893 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:51:02,893 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:51:03,437 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:51:08,126 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:51:08,318 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:51:08,319 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:51:08,319 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:51:08,320 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:51:08,438 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:51:09,438 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:51:13,321 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:51:14,164 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:51:14,165 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:51:14,165 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:51:14,166 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:51:14,166 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:51:14,440 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:51:15,440 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:51:17,892 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:51:17,893 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:51:19,115 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:51:20,122 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:51:20,122 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:51:20,123 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:51:20,123 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:51:20,441 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:51:21,442 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:51:24,124 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:51:25,979 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:51:25,979 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:51:25,980 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:51:25,980 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:51:26,443 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:51:27,443 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:51:29,981 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:51:31,883 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:51:31,884 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:51:31,884 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:51:31,884 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:51:32,445 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:51:32,893 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:51:32,893 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:51:33,445 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:51:35,015 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:51:37,826 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:51:37,827 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:51:37,827 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:51:37,827 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:51:38,446 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:51:39,447 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:51:40,828 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:51:43,670 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:51:43,671 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:51:43,671 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:51:43,671 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:51:44,165 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:51:44,448 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:51:45,448 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:51:46,165 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:51:47,893 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:51:47,893 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:51:49,606 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:51:49,606 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:51:49,607 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:51:49,607 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:51:50,450 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:51:51,450 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:51:51,607 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:51:55,470 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:51:55,471 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:51:55,471 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:51:55,471 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:51:56,451 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:51:57,452 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:51:57,472 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:52:01,358 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:52:01,358 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:52:01,359 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:52:01,359 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:52:01,453 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:52:02,893 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:52:02,893 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:52:02,893 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:52:03,453 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:52:07,298 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:52:07,299 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:52:07,299 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:52:07,299 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:52:07,454 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:52:08,299 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:52:09,455 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:52:13,145 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:52:13,146 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:52:13,146 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:52:13,146 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:52:13,456 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:52:13,456 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:52:14,147 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:52:14,165 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:52:17,893 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:52:17,893 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:52:19,070 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:52:19,070 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:52:19,071 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:52:19,071 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:52:19,458 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:52:19,458 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:52:20,071 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:52:24,930 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:52:24,930 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:52:24,930 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:52:24,931 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:52:25,460 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:52:25,460 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:52:25,931 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:52:30,832 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:52:30,833 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:52:30,833 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:52:30,833 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:52:31,461 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:52:31,461 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:52:31,834 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:52:32,893 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:52:32,893 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:52:36,766 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:52:36,767 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:52:36,767 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:52:36,767 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:52:37,463 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:52:37,463 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:52:37,767 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:52:42,615 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:52:42,615 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:52:42,616 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:52:42,617 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:52:43,465 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:52:43,465 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:52:43,617 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:52:44,166 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:52:47,893 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:52:47,894 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:52:48,558 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:52:48,559 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:52:48,559 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:52:48,559 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:52:49,466 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:52:49,466 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:52:49,559 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:52:54,393 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:52:54,393 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:52:54,393 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:52:54,394 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:52:54,467 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:52:55,394 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:52:55,468 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:53:00,299 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:53:00,300 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:53:00,300 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:53:00,300 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:53:00,469 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:53:01,301 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:53:01,469 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:53:02,893 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:53:02,894 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:53:06,246 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:53:06,246 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:53:06,247 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:53:06,247 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:53:06,470 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:53:07,247 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:53:07,471 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:53:12,092 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:53:12,093 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:53:12,093 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:53:12,093 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:53:12,472 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:53:13,094 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:53:13,472 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:53:14,166 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:53:17,893 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:53:17,894 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:53:18,030 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:53:18,061 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:53:18,061 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:53:18,061 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:53:18,474 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:53:19,062 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:53:19,474 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:53:23,934 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:53:23,934 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:53:23,935 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:53:23,935 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:53:24,475 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:53:24,935 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:53:25,475 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:53:29,786 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:53:29,786 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:53:29,786 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:53:29,787 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:53:30,477 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:53:30,787 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:53:31,477 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:53:32,893 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:53:32,894 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:53:35,734 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:53:35,734 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:53:35,735 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:53:35,735 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:53:36,478 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:53:36,735 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:53:37,478 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:53:41,592 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:53:41,593 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:53:41,593 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:53:41,593 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:53:42,480 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:53:42,593 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:53:43,480 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:53:44,167 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:53:47,485 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:53:47,486 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:53:47,486 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:53:47,486 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:53:47,894 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:53:47,894 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:53:47,894 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:53:48,481 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:53:49,481 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:53:53,056 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:53:53,430 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:53:53,430 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:53:53,431 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:53:53,431 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:53:53,482 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:53:55,483 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:53:58,432 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:53:59,301 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:53:59,302 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:53:59,302 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:53:59,302 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:53:59,484 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:53:59,484 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:54:02,894 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:54:02,894 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:54:04,089 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:54:05,238 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:54:05,242 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:54:05,242 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:54:05,242 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:54:05,485 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:54:05,485 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:54:09,243 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:54:11,087 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:54:11,088 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:54:11,088 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:54:11,089 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:54:11,486 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:54:11,487 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:54:14,167 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:54:15,168 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:54:16,972 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:54:16,972 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:54:16,972 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:54:16,973 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:54:17,488 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:54:17,488 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:54:17,894 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:54:17,894 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:54:21,080 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:54:22,914 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:54:22,914 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:54:22,915 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:54:22,915 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:54:23,489 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:54:23,490 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:54:26,916 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:54:28,767 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:54:28,768 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:54:28,768 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:54:28,768 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:54:29,491 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:54:29,491 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:54:32,769 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:54:32,894 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:54:32,894 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:54:34,702 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:54:34,702 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:54:34,703 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:54:34,703 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:54:35,492 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:54:35,493 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:54:38,704 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:54:40,560 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:54:40,560 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:54:40,560 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:54:40,561 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:54:41,494 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:54:41,494 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:54:44,168 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:54:44,169 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:54:46,461 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:54:46,462 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:54:46,462 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:54:46,462 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:54:46,495 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:54:47,495 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:54:47,894 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:54:47,894 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:54:50,092 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:54:52,402 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:54:52,403 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:54:52,403 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:54:52,403 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:54:52,497 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:54:53,497 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:54:55,404 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:54:58,268 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:54:58,269 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:54:58,269 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:54:58,270 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:54:58,498 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:54:59,498 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:55:01,270 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:55:02,894 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:55:02,895 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:55:04,210 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:55:04,210 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:55:04,211 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:55:04,211 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:55:04,500 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:55:05,500 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:55:07,212 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:55:10,077 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:55:10,078 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:55:10,078 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:55:10,078 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:55:10,501 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:55:11,502 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:55:13,079 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:55:14,168 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:55:15,969 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:55:15,969 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:55:15,970 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:55:15,970 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:55:16,503 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:55:17,504 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:55:17,894 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:55:17,895 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:55:19,034 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:55:21,910 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:55:21,910 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:55:21,911 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:55:21,911 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:55:22,505 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:55:23,506 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:55:24,912 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:55:27,767 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:55:27,767 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:55:27,767 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:55:27,768 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:55:28,507 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:55:29,507 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:55:30,768 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:55:32,895 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:55:32,895 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:55:33,660 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:55:33,660 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:55:33,660 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:55:33,661 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:55:34,509 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:55:35,509 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:55:36,661 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:55:39,574 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:55:39,574 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:55:39,574 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:55:39,575 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:55:40,511 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:55:41,511 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:55:42,575 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:55:44,169 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:55:45,472 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:55:45,473 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:55:45,473 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:55:45,473 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:55:45,512 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:55:47,513 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:55:47,894 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:55:47,895 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:55:47,895 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:55:51,414 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:55:51,414 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:55:51,415 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:55:51,415 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:55:51,514 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:55:51,514 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:55:53,415 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:55:57,275 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:55:57,275 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:55:57,275 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:55:57,276 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:55:57,516 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:55:57,516 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:55:59,276 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:56:02,895 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:56:02,895 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:56:03,214 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:56:03,214 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:56:03,215 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:56:03,215 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:56:03,518 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:56:03,518 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:56:05,215 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:56:09,070 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:56:09,071 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:56:09,071 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:56:09,071 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:56:09,520 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:56:09,520 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:56:11,072 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:56:14,169 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:56:14,987 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:56:14,988 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:56:14,988 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:56:14,988 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:56:15,522 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:56:15,522 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:56:16,989 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:56:17,895 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:56:17,895 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:56:20,930 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:56:20,930 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:56:20,931 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:56:20,931 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:56:21,523 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:56:21,523 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:56:22,931 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:56:26,789 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:56:26,789 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:56:26,790 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:56:26,790 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:56:27,525 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:56:27,525 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:56:28,790 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:56:32,687 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:56:32,688 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:56:32,688 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:56:32,688 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:56:32,895 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:56:32,895 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:56:33,526 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:56:33,526 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:56:34,119 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:56:38,622 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:56:38,622 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:56:38,623 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:56:38,623 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:56:39,528 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:56:39,623 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:56:40,528 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:56:44,170 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:56:44,470 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:56:44,471 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:56:44,471 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:56:44,471 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:56:44,529 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:56:45,472 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:56:46,530 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:56:47,896 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:56:47,896 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:56:50,369 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:56:50,369 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:56:50,369 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:56:50,370 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:56:50,531 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:56:51,370 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:56:52,531 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:56:56,274 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:56:56,275 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:56:56,275 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:56:56,275 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:56:56,532 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:56:57,276 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:56:58,533 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:57:02,188 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:57:02,188 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:57:02,189 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:57:02,189 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:57:02,534 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:57:02,895 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:57:02,895 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:57:02,896 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:57:04,535 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:57:08,085 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:57:08,130 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:57:08,130 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:57:08,131 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:57:08,131 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:57:08,536 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:57:10,536 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:57:13,132 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:57:13,986 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:57:13,986 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:57:13,987 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:57:13,987 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:57:14,174 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:57:14,537 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:57:16,538 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:57:17,895 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:57:17,896 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:57:19,083 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:57:19,918 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:57:19,918 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:57:19,919 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:57:19,919 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:57:20,539 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:57:22,540 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:57:24,920 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:57:25,762 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:57:25,763 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:57:25,763 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:57:25,763 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:57:26,541 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:57:28,542 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:57:30,764 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:57:31,666 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:57:31,667 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:57:31,667 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:57:31,667 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:57:32,543 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:57:32,895 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:57:32,896 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:57:34,543 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:57:36,125 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:57:37,568 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:57:37,569 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:57:37,569 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:57:37,569 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:57:38,544 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:57:38,544 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:57:41,570 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:57:43,466 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:57:43,467 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:57:43,467 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:57:43,468 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:57:43,546 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:57:44,171 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:57:44,546 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:57:47,172 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:57:47,896 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:57:47,896 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:57:49,418 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:57:49,418 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:57:49,419 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:57:49,420 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:57:49,547 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:57:50,547 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:57:52,420 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:57:55,330 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:57:55,330 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:57:55,330 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:57:55,331 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:57:55,549 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:57:56,549 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:57:58,331 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:58:01,228 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:58:01,228 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:58:01,228 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:58:01,229 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:58:01,550 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:58:02,551 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:58:02,896 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:58:02,896 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:58:04,035 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:58:07,158 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:58:07,158 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:58:07,159 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:58:07,159 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:58:07,552 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:58:08,552 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:58:09,159 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:58:13,019 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:58:13,020 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:58:13,020 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:58:13,021 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:58:13,553 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:58:14,171 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:58:14,172 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:58:14,554 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:58:17,896 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:58:17,896 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:58:18,938 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:58:18,938 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:58:18,939 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:58:18,939 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:58:19,555 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:58:19,939 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:58:20,556 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:58:24,793 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:58:24,793 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:58:24,793 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:58:24,794 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:58:25,557 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:58:25,794 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:58:26,557 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:58:30,702 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:58:30,703 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:58:30,703 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:58:30,703 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:58:31,559 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:58:31,704 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:58:32,559 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:58:32,897 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:58:32,898 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:58:37,130 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:58:42,131 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:58:44,172 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:58:46,562 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:58:47,897 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:58:47,898 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:58:47,898 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:58:50,866 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:58:50,867 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:58:50,867 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:58:50,979 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:58:51,564 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:58:52,564 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:58:52,979 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:58:56,675 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:58:56,676 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:58:56,676 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:58:56,867 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:58:57,565 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:58:58,566 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:58:58,867 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:59:02,535 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:59:02,535 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:59:02,536 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:59:02,536 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:59:02,567 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:59:02,897 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:59:02,898 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:59:04,067 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:59:04,567 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:59:08,442 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:59:08,442 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:59:08,443 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:59:08,443 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:59:08,568 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:59:09,443 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:59:10,569 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:59:14,172 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:59:14,291 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:59:14,291 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:59:14,291 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:59:14,292 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:59:14,570 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:59:15,292 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:59:16,570 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:59:17,898 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:59:17,898 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:59:20,210 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:59:20,210 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:59:20,211 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:59:20,211 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:59:20,571 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:59:21,211 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:59:22,572 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:59:26,051 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:59:26,052 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:59:26,052 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:59:26,052 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:59:26,573 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:59:27,053 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:59:28,574 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:59:31,933 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:59:31,933 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:59:31,934 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:59:31,934 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:59:32,575 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:59:32,898 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:59:32,899 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:59:32,899 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:59:34,575 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:59:37,858 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:59:37,858 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:59:37,859 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:59:37,859 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:59:38,577 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:59:38,859 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:59:40,577 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:59:43,729 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:59:43,730 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:59:43,730 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:59:43,730 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:59:44,173 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 20:59:44,173 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:59:44,578 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:59:46,579 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:59:47,898 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 20:59:47,898 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 20:59:49,630 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:59:49,630 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:59:49,631 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:59:49,631 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:59:49,631 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:59:50,580 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 20:59:50,580 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:59:54,632 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 20:59:55,517 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 20:59:55,518 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 20:59:55,518 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 20:59:55,519 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 20:59:55,581 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 20:59:56,582 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:00:00,520 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:00:01,404 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:00:01,405 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:00:01,405 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:00:01,405 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:00:01,583 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:00:02,583 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:00:02,898 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:00:02,898 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:00:06,042 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:00:07,292 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:00:07,292 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:00:07,293 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:00:07,293 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:00:07,585 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:00:08,585 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:00:11,293 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:00:13,188 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:00:13,188 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:00:13,188 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:00:13,189 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:00:13,587 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:00:14,173 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:00:14,587 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:00:17,174 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:00:17,898 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:00:17,898 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:00:19,089 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:00:19,090 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:00:19,090 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:00:19,090 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:00:19,588 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:00:20,589 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:00:23,091 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:00:24,973 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:00:24,976 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:00:24,977 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:00:24,977 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:00:25,590 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:00:26,590 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:00:28,978 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:00:30,878 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:00:30,879 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:00:30,879 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:00:30,879 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:00:31,592 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:00:32,592 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:00:32,898 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:00:32,898 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:00:34,117 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:00:36,768 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:00:36,768 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:00:36,768 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:00:36,769 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:00:37,593 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:00:38,594 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:00:39,769 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:00:42,669 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:00:42,669 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:00:42,670 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:00:42,670 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:00:43,595 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:00:44,174 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:00:44,595 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:00:45,174 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:00:47,899 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:00:47,899 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:00:48,559 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:00:48,559 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:00:48,559 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:00:48,560 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:00:48,597 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:00:50,560 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:00:50,597 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:00:54,446 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:00:54,447 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:00:54,447 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:00:54,447 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:00:54,598 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:00:56,448 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:00:56,599 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:01:00,332 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:01:00,333 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:01:00,333 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:01:00,333 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:01:00,600 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:01:02,334 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:01:02,600 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:01:02,898 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:01:02,899 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:01:06,223 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:01:06,224 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:01:06,224 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:01:06,224 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:01:06,601 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:01:08,225 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:01:08,602 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:01:12,112 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:01:12,113 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:01:12,113 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:01:12,113 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:01:12,603 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:01:14,114 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:01:14,174 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:01:14,604 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:01:17,898 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:01:17,899 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:01:18,015 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:01:18,034 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:01:18,034 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:01:18,034 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:01:18,605 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:01:20,035 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:01:20,605 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:01:23,942 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:01:23,943 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:01:23,943 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:01:23,943 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:01:24,606 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:01:25,943 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:01:26,607 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:01:30,944 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:01:35,945 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:01:37,877 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:01:37,877 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:01:41,011 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:01:42,100 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:01:42,101 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:01:42,101 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:01:42,101 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:01:42,611 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:01:44,175 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:01:44,612 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:01:46,175 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:01:47,935 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:01:47,935 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:01:47,936 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:01:47,936 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:01:48,613 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:01:50,614 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:01:51,937 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:01:52,876 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:01:52,877 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:01:53,801 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:01:53,802 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:01:53,802 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:01:53,802 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:01:54,615 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:01:54,615 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:01:57,803 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:01:59,677 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:01:59,678 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:01:59,678 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:01:59,679 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:02:00,616 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:02:00,616 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:02:03,680 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:02:05,555 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:02:05,556 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:02:05,556 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:02:05,556 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:02:05,617 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:02:06,618 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:02:07,877 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:02:07,877 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:02:09,004 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:02:11,462 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:02:11,462 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:02:11,463 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:02:11,463 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:02:11,619 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:02:12,619 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:02:14,175 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:02:14,175 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:02:17,299 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:02:17,300 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:02:17,300 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:02:17,300 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:02:17,621 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:02:18,621 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:02:19,300 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:02:22,877 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:02:22,877 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:02:23,226 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:02:23,226 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:02:23,227 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:02:23,227 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:02:23,622 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:02:24,623 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:02:25,227 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:02:29,067 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:02:29,068 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:02:29,068 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:02:29,068 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:02:29,624 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:02:30,624 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:02:31,069 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:02:34,955 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:02:34,955 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:02:34,955 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:02:34,956 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:02:35,625 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:02:36,626 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:02:36,956 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:02:37,877 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:02:37,877 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:02:40,898 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:02:40,898 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:02:40,899 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:02:40,899 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:02:41,627 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:02:42,627 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:02:42,899 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:02:44,176 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:02:46,745 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:02:46,746 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:02:46,746 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:02:46,746 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:02:47,628 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:02:48,628 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:02:48,746 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:02:52,650 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:02:52,651 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:02:52,651 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:02:52,651 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:02:52,877 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:02:52,877 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:02:53,630 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:02:54,088 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:02:54,630 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:02:58,544 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:02:58,544 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:02:58,544 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:02:58,545 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:02:58,631 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:02:59,545 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:03:00,631 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:03:04,438 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:03:04,439 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:03:04,439 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:03:04,439 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:03:04,632 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:03:05,440 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:03:06,633 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:03:07,877 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:03:07,877 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:03:10,330 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:03:10,331 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:03:10,331 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:03:10,331 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:03:10,633 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:03:11,332 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:03:12,634 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:03:14,176 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:03:16,236 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:03:16,236 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:03:16,237 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:03:16,237 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:03:16,635 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:03:17,237 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:03:18,635 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:03:22,134 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:03:22,135 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:03:22,135 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:03:22,135 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:03:22,636 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:03:22,877 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:03:22,877 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:03:23,106 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:03:24,637 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:03:28,029 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:03:28,029 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:03:28,030 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:03:28,030 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:03:28,638 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:03:29,030 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:03:30,638 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:03:33,919 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:03:33,920 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:03:33,920 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:03:33,920 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:03:34,639 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:03:34,640 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:03:34,921 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:03:37,877 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:03:37,878 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:03:39,862 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:03:39,862 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:03:39,863 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:03:39,863 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:03:40,641 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:03:40,641 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:03:40,863 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:03:44,180 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:03:45,720 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:03:45,721 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:03:45,721 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:03:45,721 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:03:46,643 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:03:46,643 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:03:46,722 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:03:51,622 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:03:51,623 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:03:51,623 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:03:51,623 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:03:51,644 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:03:52,624 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:03:52,644 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:03:52,877 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:03:52,878 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:03:57,505 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:03:57,506 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:03:57,506 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:03:57,506 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:03:57,646 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:03:58,507 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:03:58,646 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:04:03,397 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:04:03,397 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:04:03,398 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:04:03,399 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:04:03,647 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:04:04,399 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:04:04,648 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:04:07,878 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:04:07,878 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:04:09,338 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:04:09,338 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:04:09,339 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:04:09,339 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:04:09,649 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:04:10,339 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:04:10,649 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:04:14,177 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:04:15,192 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:04:15,193 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:04:15,193 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:04:15,193 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:04:15,650 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:04:16,194 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:04:16,651 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:04:21,082 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:04:21,082 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:04:21,083 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:04:21,083 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:04:21,652 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:04:22,083 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:04:22,652 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:04:22,878 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:04:22,878 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:04:27,010 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:04:27,010 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:04:27,011 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:04:27,011 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:04:27,654 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:04:28,011 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:04:28,654 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:04:32,855 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:04:32,856 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:04:32,856 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:04:32,856 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:04:33,655 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:04:33,856 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:04:34,656 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:04:37,878 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:04:37,878 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:04:38,798 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:04:38,798 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:04:38,799 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:04:38,799 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:04:39,657 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:04:39,799 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:04:40,657 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:04:44,178 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:04:44,646 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:04:44,646 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:04:44,647 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:04:44,647 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:04:44,658 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:04:45,647 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:04:46,659 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:04:50,537 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:04:50,537 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:04:50,537 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:04:50,537 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:04:50,660 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:04:51,538 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:04:52,660 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:04:52,878 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:04:52,879 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:04:56,478 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:04:56,478 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:04:56,479 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:04:56,479 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:04:56,661 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:04:57,479 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:04:58,662 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:05:02,337 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:05:02,338 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:05:02,338 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:05:02,338 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:05:02,663 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:05:03,339 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:05:04,663 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:05:07,878 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:05:07,879 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:05:08,274 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:05:08,274 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:05:08,275 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:05:08,275 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:05:08,664 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:05:09,275 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:05:10,665 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:05:14,133 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:05:14,133 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:05:14,133 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:05:14,134 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:05:14,178 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:05:14,666 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:05:15,178 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:05:16,667 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:05:20,016 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:05:20,017 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:05:20,017 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:05:20,017 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:05:20,668 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:05:20,668 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:05:21,018 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:05:22,878 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:05:22,878 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:05:25,958 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:05:25,958 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:05:25,959 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:05:25,959 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:05:26,669 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:05:26,669 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:05:26,959 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:05:31,807 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:05:31,807 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:05:31,808 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:05:31,808 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:05:32,671 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:05:32,671 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:05:32,808 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:05:37,705 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:05:37,706 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:05:37,706 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:05:37,707 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:05:37,878 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:05:37,878 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:05:37,879 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:05:38,672 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:05:38,672 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:05:43,063 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:05:43,646 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:05:43,646 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:05:43,647 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:05:43,647 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:05:43,673 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:05:44,179 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:05:44,674 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:05:48,180 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:05:49,503 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:05:49,503 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:05:49,503 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:05:49,504 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:05:49,675 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:05:50,675 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:05:52,878 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:05:52,879 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:05:54,110 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:05:55,442 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:05:55,442 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:05:55,443 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:05:55,443 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:05:55,677 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:05:56,677 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:05:59,444 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:06:01,289 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:06:01,289 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:06:01,290 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:06:01,290 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:06:01,678 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:06:02,678 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:06:05,291 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:06:07,192 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:06:07,192 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:06:07,193 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:06:07,193 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:06:07,679 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:06:07,878 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:06:07,879 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:06:08,680 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:06:11,059 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:06:13,126 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:06:13,126 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:06:13,127 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:06:13,127 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:06:13,681 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:06:14,179 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:06:14,681 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:06:16,180 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:06:18,980 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:06:18,980 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:06:18,980 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:06:18,981 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:06:19,683 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:06:20,683 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:06:21,981 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:06:22,878 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:06:22,879 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:06:24,914 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:06:24,914 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:06:24,915 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:06:24,915 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:06:25,684 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:06:26,684 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:06:27,916 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:06:30,781 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:06:30,781 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:06:30,781 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:06:30,782 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:06:31,686 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:06:32,686 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:06:33,782 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:06:36,665 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:06:36,666 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:06:36,666 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:06:36,667 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:06:36,687 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:06:37,879 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:06:37,879 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:06:38,688 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:06:39,107 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:06:42,598 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:06:42,598 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:06:42,599 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:06:42,599 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:06:42,689 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:06:44,180 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:06:44,180 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:06:44,689 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:06:48,450 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:06:48,454 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:06:48,454 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:06:48,455 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:06:48,690 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:06:49,455 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:06:50,691 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:06:52,879 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:06:52,879 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:06:54,394 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:06:54,394 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:06:54,395 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:06:54,395 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:06:54,692 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:06:55,395 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:06:56,692 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:07:00,247 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:07:00,248 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:07:00,248 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:07:00,248 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:07:00,693 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:07:01,249 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:07:02,694 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:07:06,143 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:07:06,143 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:07:06,144 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:07:06,144 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:07:06,695 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:07:06,695 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:07:07,144 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:07:07,879 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:07:07,879 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:07:12,082 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:07:12,082 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:07:12,083 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:07:12,084 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:07:12,696 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:07:12,696 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:07:13,084 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:07:14,180 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:07:17,939 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:07:17,939 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:07:17,939 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:07:17,940 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:07:18,698 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:07:18,698 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:07:18,940 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:07:22,879 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:07:22,879 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:07:23,862 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:07:23,862 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:07:23,863 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:07:23,863 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:07:24,700 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:07:24,700 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:07:24,863 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:07:29,706 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:07:29,707 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:07:29,707 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:07:29,707 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:07:30,701 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:07:30,702 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:07:30,708 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:07:35,595 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:07:35,595 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:07:35,596 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:07:35,596 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:07:35,703 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:07:36,596 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:07:36,703 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:07:37,879 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:07:37,880 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:07:41,534 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:07:41,534 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:07:41,535 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:07:41,535 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:07:41,704 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:07:42,535 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:07:42,705 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:07:44,181 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:07:47,385 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:07:47,386 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:07:47,386 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:07:47,386 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:07:47,706 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:07:48,387 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:07:48,706 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:07:52,879 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:07:52,879 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:07:53,306 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:07:53,306 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:07:53,307 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:07:53,307 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:07:53,708 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:07:54,307 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:07:54,708 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:07:59,160 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:07:59,160 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:07:59,160 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:07:59,161 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:07:59,710 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:08:00,161 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:08:00,710 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:08:05,052 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:08:05,052 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:08:05,052 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:08:05,053 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:08:05,711 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:08:06,053 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:08:06,711 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:08:07,879 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:08:07,880 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:08:10,986 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:08:10,986 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:08:10,987 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:08:10,987 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:08:11,713 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:08:11,987 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:08:12,713 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:08:14,181 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:08:16,859 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:08:16,860 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:08:16,860 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:08:16,860 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:08:17,714 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:08:17,860 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:08:18,714 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:08:22,748 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:08:22,749 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:08:22,749 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:08:22,749 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:08:22,879 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:08:22,880 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:08:22,880 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:08:23,716 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:08:24,716 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:08:28,043 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:08:28,694 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:08:28,694 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:08:28,695 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:08:28,695 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:08:28,717 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:08:30,717 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:08:33,696 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:08:34,550 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:08:34,550 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:08:34,550 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:08:34,551 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:08:34,718 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:08:36,719 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:08:37,879 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:08:37,880 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:08:39,060 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:08:40,506 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:08:40,506 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:08:40,507 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:08:40,507 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:08:40,720 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:08:42,721 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:08:44,182 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:08:44,182 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:08:46,359 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:08:46,360 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:08:46,360 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:08:46,360 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:08:46,722 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:08:46,722 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:08:49,361 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:08:52,880 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:08:52,880 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:08:55,125 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:09:00,126 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:09:02,725 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:09:06,087 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:09:06,859 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:09:06,860 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:09:06,860 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:09:06,872 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:09:07,727 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:09:07,880 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:09:07,880 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:09:08,727 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:09:11,090 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:09:12,742 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:09:12,743 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:09:12,743 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:09:12,917 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:09:13,728 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:09:14,182 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:09:14,729 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:09:16,183 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:09:18,560 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:09:18,560 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:09:18,561 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:09:18,561 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:09:18,730 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:09:20,730 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:09:21,561 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:09:22,880 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:09:22,880 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:09:24,502 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:09:24,502 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:09:24,503 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:09:24,503 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:09:24,731 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:09:26,732 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:09:27,503 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:09:30,332 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:09:30,333 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:09:30,333 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:09:30,333 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:09:30,733 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:09:30,733 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:09:33,334 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:09:36,234 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:09:36,235 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:09:36,235 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:09:36,235 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:09:36,734 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:09:36,735 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:09:37,880 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:09:37,881 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:09:39,034 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:09:42,142 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:09:42,142 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:09:42,143 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:09:42,143 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:09:42,736 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:09:42,736 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:09:44,143 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:09:44,182 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:09:48,001 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:09:48,001 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:09:48,001 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:09:48,002 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:09:48,737 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:09:48,738 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:09:50,002 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:09:52,881 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:09:52,881 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:09:53,901 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:09:53,901 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:09:53,901 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:09:53,902 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:09:54,739 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:09:54,739 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:09:55,902 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:09:59,788 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:09:59,789 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:09:59,789 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:09:59,789 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:10:00,740 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:10:00,740 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:10:01,790 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:10:05,680 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:10:05,681 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:10:05,681 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:10:05,682 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:10:05,742 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:10:06,742 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:10:07,682 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:10:07,880 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:10:07,881 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:10:11,582 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:10:11,589 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:10:11,590 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:10:11,590 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:10:11,743 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:10:12,743 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:10:13,590 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:10:14,183 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:10:17,502 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:10:17,502 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:10:17,502 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:10:17,503 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:10:17,744 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:10:18,745 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:10:19,503 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:10:22,881 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:10:22,881 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:10:23,424 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:10:23,424 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:10:23,425 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:10:23,425 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:10:23,746 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:10:24,746 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:10:25,425 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:10:29,337 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:10:29,338 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:10:29,338 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:10:29,338 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:10:29,747 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:10:30,748 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:10:31,339 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:10:35,228 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:10:35,228 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:10:35,228 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:10:35,229 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:10:35,749 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:10:36,749 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:10:37,229 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:10:37,881 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:10:37,881 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:10:41,115 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:10:41,116 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:10:41,116 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:10:41,116 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:10:41,750 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:10:42,751 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:10:43,117 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:10:44,183 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:10:47,009 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:10:47,009 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:10:47,010 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:10:47,010 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:10:47,752 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:10:48,752 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:10:49,010 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:10:52,881 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:10:52,881 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:10:52,903 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:10:53,043 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:10:53,044 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:10:53,044 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:10:53,753 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:10:54,044 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:10:54,754 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:10:58,798 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:10:58,798 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:10:58,798 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:10:58,799 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:10:59,755 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:10:59,799 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:11:00,755 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:11:04,684 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:11:04,685 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:11:04,685 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:11:04,685 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:11:04,756 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:11:05,686 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:11:06,757 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:11:07,881 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:11:07,881 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:11:10,562 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:11:10,563 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:11:10,563 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:11:10,563 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:11:10,758 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:11:11,564 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:11:12,758 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:11:14,184 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:11:16,454 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:11:16,455 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:11:16,455 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:11:16,455 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:11:16,759 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:11:16,759 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:11:17,455 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:11:22,338 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:11:22,339 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:11:22,339 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:11:22,339 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:11:22,761 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:11:22,761 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:11:22,881 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:11:22,881 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:11:23,101 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:11:28,102 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:11:28,229 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:11:28,230 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:11:28,230 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:11:28,230 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:11:28,762 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:11:28,762 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:11:33,231 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:11:34,109 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:11:34,110 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:11:34,110 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:11:34,110 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:11:34,763 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:11:34,763 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:11:37,881 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:11:37,881 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:11:39,092 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:11:39,994 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:11:39,995 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:11:39,995 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:11:39,995 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:11:40,765 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:11:40,765 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:11:44,185 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:11:44,185 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:11:45,876 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:11:45,876 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:11:45,876 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:11:45,876 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:11:46,766 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:11:46,766 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:11:49,877 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:11:51,767 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:11:51,768 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:11:51,768 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:11:51,768 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:11:52,768 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:11:52,768 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:11:52,881 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:11:52,882 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:11:55,029 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:11:57,661 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:11:57,662 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:11:57,662 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:11:57,662 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:11:57,769 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:11:58,770 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:12:00,663 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:12:03,553 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:12:03,554 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:12:03,554 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:12:03,554 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:12:03,771 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:12:04,771 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:12:06,555 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:12:07,881 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:12:07,882 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:12:09,448 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:12:09,449 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:12:09,449 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:12:09,449 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:12:09,773 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:12:10,773 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:12:12,450 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:12:14,185 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:12:15,343 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:12:15,344 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:12:15,344 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:12:15,344 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:12:15,774 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:12:16,775 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:12:18,345 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:12:21,224 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:12:21,225 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:12:21,225 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:12:21,225 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:12:21,776 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:12:22,776 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:12:22,882 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:12:22,882 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:12:24,079 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:12:27,111 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:12:27,111 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:12:27,111 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:12:27,112 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:12:27,778 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:12:28,778 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:12:29,112 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:12:33,004 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:12:33,005 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:12:33,005 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:12:33,005 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:12:33,779 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:12:34,779 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:12:35,006 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:12:37,882 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:12:37,882 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:12:38,930 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:12:38,931 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:12:38,931 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:12:38,931 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:12:39,781 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:12:40,781 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:12:40,932 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:12:44,185 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:12:44,765 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:12:44,766 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:12:44,766 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:12:44,766 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:12:44,782 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:12:46,767 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:12:46,782 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:12:50,670 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:12:50,671 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:12:50,671 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:12:50,671 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:12:50,783 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:12:52,672 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:12:52,784 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:12:52,882 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:12:52,882 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:12:56,553 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:12:56,553 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:12:56,554 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:12:56,554 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:12:56,785 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:12:56,785 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:12:58,554 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:13:02,437 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:13:02,437 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:13:02,438 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:13:02,438 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:13:02,787 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:13:02,787 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:13:04,438 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:13:07,882 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:13:07,882 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:13:08,332 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:13:08,332 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:13:08,333 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:13:08,333 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:13:08,788 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:13:08,788 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:13:10,333 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:13:14,189 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:13:14,223 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:13:14,224 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:13:14,224 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:13:14,224 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:13:14,790 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:13:14,790 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:13:16,225 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:13:20,111 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:13:20,112 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:13:20,112 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:13:20,112 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:13:20,791 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:13:20,791 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:13:22,113 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:13:22,882 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:13:22,882 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:13:26,006 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:13:26,006 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:13:26,007 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:13:26,007 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:13:26,793 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:13:26,793 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:13:28,007 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:13:31,891 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:13:31,891 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:13:31,892 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:13:31,892 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:13:32,794 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:13:32,794 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:13:33,893 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:13:37,784 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:13:37,785 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:13:37,785 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:13:37,785 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:13:37,796 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:13:37,882 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:13:37,883 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:13:38,796 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:13:39,112 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:13:43,710 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:13:43,711 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:13:43,711 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:13:43,711 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:13:43,797 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:13:44,186 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:13:44,187 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:13:45,798 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:13:49,188 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:13:49,552 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:13:49,553 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:13:49,553 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:13:49,553 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:13:49,799 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:13:51,799 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:13:54,554 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:13:59,555 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:14:03,096 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:14:03,096 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:14:05,274 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:14:07,842 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:14:07,842 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:14:07,843 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:14:07,843 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:14:08,803 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:14:09,804 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:14:10,844 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:14:13,688 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:14:13,689 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:14:13,689 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:14:13,689 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:14:13,805 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:14:14,187 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:14:15,805 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:14:16,188 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:14:18,096 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:14:18,096 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:14:19,586 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:14:19,586 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:14:19,587 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:14:19,587 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:14:19,806 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:14:21,588 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:14:21,807 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:14:25,409 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:14:25,410 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:14:25,410 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:14:25,410 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:14:25,807 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:14:27,411 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:14:27,808 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:14:31,310 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:14:31,311 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:14:31,311 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:14:31,311 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:14:31,809 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:14:33,096 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:14:33,096 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:14:33,097 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:14:33,809 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:14:37,230 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:14:37,230 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:14:37,231 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:14:37,231 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:14:37,811 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:14:38,231 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:14:39,811 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:14:43,069 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:14:43,070 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:14:43,070 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:14:43,070 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:14:43,812 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:14:44,071 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:14:44,187 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:14:45,813 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:14:48,096 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:14:48,097 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:14:48,990 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:14:48,991 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:14:48,991 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:14:48,991 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:14:49,814 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:14:49,991 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:14:51,814 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:14:54,828 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:14:54,829 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:14:54,829 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:14:54,829 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:14:55,815 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:14:55,829 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:14:57,816 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:15:00,710 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:15:00,711 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:15:00,711 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:15:00,711 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:15:00,817 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:15:01,712 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:15:01,817 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:15:03,097 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:15:03,097 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:15:06,670 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:15:06,670 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:15:06,671 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:15:06,671 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:15:06,818 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:15:07,671 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:15:07,818 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:15:12,527 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:15:12,528 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:15:12,528 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:15:12,528 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:15:12,819 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:15:13,529 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:15:13,820 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:15:14,188 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:15:18,096 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:15:18,097 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:15:18,454 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:15:18,455 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:15:18,455 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:15:18,456 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:15:18,821 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:15:19,456 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:15:19,821 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:15:24,350 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:15:24,351 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:15:24,351 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:15:24,351 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:15:24,822 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:15:25,352 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:15:25,823 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:15:30,252 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:15:30,253 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:15:30,253 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:15:30,253 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:15:30,824 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:15:31,254 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:15:31,824 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:15:33,096 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:15:33,097 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:15:36,186 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:15:36,186 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:15:36,187 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:15:36,187 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:15:36,827 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:15:37,187 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:15:37,827 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:15:42,029 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:15:42,030 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:15:42,030 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:15:42,030 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:15:42,828 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:15:43,031 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:15:43,829 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:15:44,188 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:15:47,923 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:15:47,924 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:15:47,924 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:15:47,924 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:15:48,097 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:15:48,097 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:15:48,097 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:15:48,830 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:15:49,830 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:15:53,327 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:15:53,850 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:15:53,850 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:15:53,851 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:15:53,851 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:15:54,831 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:15:55,831 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:15:58,852 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:15:59,695 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:15:59,696 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:15:59,696 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:15:59,696 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:15:59,832 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:16:01,833 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:16:03,097 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:16:03,097 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:16:04,303 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:16:05,618 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:16:05,618 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:16:05,619 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:16:05,619 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:16:05,834 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:16:07,834 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:16:09,620 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:16:11,451 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:16:11,451 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:16:11,452 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:16:11,452 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:16:11,835 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:16:13,836 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:16:14,189 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:16:15,190 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:16:17,343 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:16:17,344 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:16:17,344 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:16:17,344 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:16:17,837 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:16:18,097 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:16:18,097 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:16:19,837 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:16:20,261 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:16:23,270 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:16:23,271 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:16:23,271 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:16:23,271 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:16:23,838 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:16:25,271 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:16:25,839 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:16:29,115 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:16:29,116 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:16:29,116 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:16:29,116 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:16:29,840 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:16:31,117 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:16:31,840 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:16:33,097 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:16:33,097 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:16:35,050 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:16:35,055 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:16:35,055 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:16:35,055 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:16:35,841 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:16:37,056 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:16:37,842 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:16:40,887 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:16:40,888 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:16:40,888 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:16:40,888 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:16:41,843 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:16:41,843 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:16:42,889 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:16:44,189 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:16:46,799 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:16:46,799 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:16:46,799 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:16:46,800 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:16:46,844 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:16:47,844 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:16:48,097 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:16:48,097 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:16:48,097 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:16:52,726 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:16:52,727 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:16:52,727 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:16:52,728 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:16:52,846 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:16:53,728 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:16:53,846 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:16:58,563 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:16:58,563 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:16:58,564 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:16:58,564 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:16:58,847 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:16:59,564 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:16:59,847 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:17:03,097 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:17:03,098 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:17:04,502 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:17:04,502 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:17:04,503 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:17:04,503 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:17:04,849 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:17:05,503 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:17:05,849 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:17:10,352 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:17:10,353 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:17:10,353 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:17:10,353 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:17:10,850 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:17:11,354 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:17:11,851 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:17:14,190 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:17:16,241 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:17:16,242 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:17:16,242 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:17:16,243 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:17:16,852 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:17:17,243 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:17:17,852 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:17:18,097 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:17:18,098 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:17:22,190 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:17:22,191 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:17:22,191 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:17:22,191 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:17:22,853 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:17:23,191 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:17:23,854 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:17:28,043 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:17:28,044 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:17:28,044 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:17:28,044 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:17:28,855 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:17:29,045 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:17:29,855 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:17:33,097 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:17:33,098 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:17:33,974 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:17:33,974 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:17:33,975 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:17:33,975 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:17:34,856 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:17:34,975 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:17:35,857 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:17:39,838 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:17:39,839 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:17:39,839 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:17:39,839 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:17:39,858 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:17:40,839 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:17:41,858 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:17:44,191 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:17:45,720 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:17:45,720 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:17:45,720 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:17:45,721 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:17:45,859 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:17:46,721 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:17:47,860 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:17:48,098 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:17:48,098 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:17:51,646 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:17:51,646 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:17:51,647 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:17:51,647 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:17:51,861 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:17:52,647 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:17:53,861 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:17:57,487 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:17:57,487 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:17:57,487 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:17:57,488 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:17:57,862 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:17:58,488 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:17:59,863 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:18:03,098 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:18:03,098 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:18:03,422 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:18:03,422 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:18:03,423 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:18:03,423 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:18:03,864 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:18:04,423 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:18:05,864 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:18:09,259 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:18:09,260 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:18:09,260 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:18:09,260 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:18:09,865 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:18:10,261 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:18:11,866 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:18:14,191 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:18:15,136 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:18:15,136 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:18:15,136 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:18:15,137 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:18:15,867 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:18:16,137 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:18:17,868 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:18:18,098 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:18:18,098 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:18:21,062 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:18:21,062 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:18:21,063 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:18:21,063 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:18:21,869 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:18:21,869 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:18:22,063 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:18:26,915 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:18:26,916 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:18:26,916 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:18:26,917 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:18:27,870 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:18:27,870 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:18:27,918 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:18:32,794 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:18:32,794 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:18:32,795 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:18:32,795 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:18:32,872 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:18:33,098 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:18:33,098 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:18:33,098 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:18:33,872 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:18:38,256 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:18:38,734 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:18:38,734 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:18:38,735 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:18:38,735 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:18:38,873 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:18:39,873 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:18:43,736 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:18:44,192 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:18:44,576 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:18:44,576 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:18:44,577 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:18:44,577 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:18:44,875 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:18:45,875 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:18:48,098 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:18:48,098 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:18:49,256 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:18:50,534 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:18:50,534 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:18:50,535 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:18:50,535 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:18:50,876 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:18:51,877 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:18:54,535 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:18:56,396 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:18:56,396 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:18:56,397 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:18:56,397 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:18:56,878 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:18:57,878 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:19:00,398 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:19:02,290 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:19:02,291 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:19:02,291 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:19:02,291 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:19:02,880 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:19:03,125 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:19:03,126 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:19:03,880 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:19:06,345 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:19:11,346 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:19:14,192 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:19:16,950 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:19:17,883 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:19:18,125 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:19:18,126 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:19:19,884 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:19:22,300 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:19:23,590 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:19:23,590 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:19:23,591 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:19:23,767 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:19:23,885 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:19:25,886 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:19:27,768 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:19:29,410 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:19:29,411 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:19:29,411 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:19:29,485 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:19:29,887 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:19:31,887 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:19:33,126 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:19:33,126 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:19:33,126 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:19:35,302 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:19:35,303 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:19:35,303 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:19:35,303 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:19:35,888 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:19:37,889 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:19:38,303 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:19:41,121 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:19:41,122 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:19:41,122 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:19:41,122 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:19:41,890 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:19:43,890 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:19:44,123 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:19:44,198 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:19:47,010 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:19:47,010 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:19:47,010 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:19:47,011 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:19:47,892 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:19:47,892 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:19:48,126 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:19:48,126 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:19:49,318 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:19:52,934 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:19:52,934 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:19:52,935 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:19:52,935 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:19:53,893 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:19:53,893 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:19:54,935 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:19:58,780 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:19:58,780 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:19:58,780 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:19:58,781 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:19:58,894 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:19:59,894 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:20:00,781 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:20:03,126 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:20:03,126 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:20:04,698 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:20:04,699 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:20:04,699 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:20:04,700 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:20:04,896 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:20:05,896 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:20:06,700 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:20:10,537 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:20:10,537 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:20:10,537 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:20:10,538 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:20:10,897 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:20:11,898 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:20:12,538 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:20:14,193 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:20:16,417 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:20:16,418 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:20:16,418 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:20:16,419 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:20:16,899 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:20:17,899 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:20:18,126 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:20:18,126 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:20:18,126 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:20:22,350 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:20:22,351 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:20:22,351 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:20:22,351 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:20:22,900 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:20:23,351 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:20:23,901 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:20:28,193 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:20:28,194 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:20:28,194 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:20:28,194 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:20:28,902 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:20:29,195 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:20:29,902 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:20:33,126 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:20:33,126 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:20:34,138 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:20:34,139 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:20:34,139 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:20:34,139 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:20:34,903 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:20:35,139 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:20:35,904 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:20:39,987 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:20:39,988 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:20:39,988 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:20:39,988 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:20:40,905 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:20:40,988 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:20:41,905 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:20:44,194 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:20:45,883 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:20:45,883 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:20:45,884 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:20:45,884 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:20:45,906 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:20:46,884 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:20:47,906 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:20:48,126 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:20:48,127 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:20:51,814 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:20:51,815 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:20:51,815 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:20:51,815 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:20:51,907 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:20:52,815 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:20:53,908 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:20:57,680 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:20:57,681 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:20:57,681 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:20:57,681 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:20:57,909 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:20:58,681 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:20:59,910 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:21:03,126 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:21:03,127 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:21:03,610 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:21:03,611 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:21:03,611 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:21:03,611 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:21:03,911 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:21:04,611 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:21:05,911 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:21:09,468 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:21:09,468 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:21:09,468 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:21:09,469 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:21:09,912 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:21:10,469 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:21:11,913 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:21:14,194 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:21:15,353 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:21:15,354 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:21:15,354 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:21:15,354 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:21:15,914 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:21:16,354 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:21:17,915 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:21:18,127 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:21:18,127 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:21:21,282 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:21:21,283 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:21:21,283 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:21:21,283 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:21:21,916 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:21:22,283 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:21:23,916 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:21:27,138 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:21:27,138 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:21:27,138 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:21:27,139 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:21:27,918 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:21:27,918 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:21:28,139 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:21:33,045 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:21:33,046 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:21:33,046 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:21:33,046 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:21:33,127 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:21:33,127 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:21:33,311 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:21:33,919 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:21:33,919 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:21:38,311 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:21:38,933 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:21:38,934 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:21:38,934 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:21:38,935 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:21:39,921 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:21:39,921 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:21:43,936 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:21:44,195 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:21:44,815 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:21:44,815 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:21:44,815 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:21:44,816 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:21:44,922 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:21:45,922 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:21:48,127 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:21:48,127 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:21:49,302 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:21:50,754 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:21:50,755 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:21:50,755 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:21:50,755 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:21:50,924 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:21:51,924 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:21:54,756 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:21:56,626 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:21:56,627 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:21:56,627 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:21:56,627 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:21:56,925 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:21:57,926 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:22:00,628 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:22:02,510 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:22:02,511 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:22:02,511 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:22:02,511 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:22:02,927 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:22:03,127 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:22:03,127 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:22:03,927 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:22:06,342 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:22:08,446 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:22:08,447 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:22:08,447 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:22:08,447 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:22:08,928 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:22:09,928 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:22:11,447 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:22:14,195 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:22:14,292 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:22:14,293 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:22:14,293 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:22:14,294 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:22:14,930 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:22:15,930 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:22:17,294 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:22:18,127 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:22:18,127 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:22:20,230 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:22:20,231 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:22:20,231 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:22:20,231 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:22:20,931 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:22:21,932 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:22:23,232 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:22:26,083 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:22:26,084 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:22:26,084 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:22:26,084 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:22:26,933 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:22:27,933 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:22:29,085 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:22:31,973 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:22:31,974 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:22:31,974 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:22:31,974 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:22:32,935 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:22:33,127 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:22:33,127 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:22:33,935 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:22:34,293 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:22:37,914 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:22:37,915 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:22:37,915 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:22:37,915 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:22:37,936 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:22:39,915 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:22:39,936 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:22:43,783 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:22:43,784 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:22:43,784 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:22:43,784 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:22:43,937 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:22:44,196 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:22:45,196 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:22:45,938 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:22:48,127 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:22:48,127 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:22:49,714 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:22:49,715 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:22:49,715 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:22:49,715 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:22:49,939 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:22:50,715 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:22:51,940 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:22:55,572 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:22:55,576 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:22:55,576 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:22:55,576 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:22:55,941 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:22:56,577 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:22:57,941 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:23:01,464 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:23:01,465 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:23:01,465 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:23:01,465 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:23:01,943 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:23:02,466 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:23:03,127 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:23:03,128 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:23:03,943 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:23:07,398 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:23:07,399 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:23:07,399 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:23:07,399 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:23:07,944 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:23:07,944 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:23:08,399 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:23:13,233 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:23:13,233 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:23:13,233 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:23:13,234 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:23:13,946 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:23:13,946 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:23:14,196 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:23:14,196 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:23:18,127 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:23:18,128 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:23:19,124 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:23:19,124 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:23:19,124 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:23:19,125 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:23:19,948 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:23:19,948 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:23:20,125 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:23:25,014 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:23:25,014 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:23:25,014 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:23:25,015 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:23:25,949 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:23:25,949 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:23:26,015 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:23:30,909 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:23:30,909 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:23:30,909 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:23:30,910 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:23:30,951 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:23:31,910 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:23:31,951 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:23:33,128 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:23:33,128 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:23:36,838 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:23:36,839 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:23:36,839 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:23:36,839 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:23:36,952 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:23:37,839 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:23:37,952 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:23:42,713 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:23:42,714 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:23:42,714 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:23:42,714 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:23:42,954 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:23:43,714 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:23:43,954 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:23:44,197 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:23:48,128 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:23:48,128 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:23:48,658 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:23:48,659 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:23:48,659 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:23:48,659 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:23:48,956 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:23:49,659 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:23:49,956 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:23:54,520 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:23:54,520 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:23:54,521 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:23:54,521 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:23:54,957 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:23:55,521 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:23:55,957 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:24:00,405 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:24:00,406 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:24:00,406 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:24:00,406 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:24:00,959 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:24:01,407 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:24:01,959 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:24:03,128 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:24:03,128 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:24:06,283 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:24:06,284 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:24:06,284 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:24:06,284 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:24:06,960 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:24:07,284 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:24:07,961 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:24:12,167 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:24:12,167 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:24:12,168 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:24:12,168 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:24:12,962 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:24:13,168 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:24:13,962 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:24:14,197 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:24:18,066 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:24:18,067 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:24:18,067 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:24:18,067 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:24:18,128 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:24:18,128 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:24:18,334 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:24:18,963 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:24:19,964 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:24:23,335 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:24:23,982 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:24:23,983 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:24:23,983 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:24:23,983 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:24:24,965 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:24:25,965 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:24:28,984 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:24:29,822 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:24:29,822 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:24:29,822 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:24:29,823 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:24:29,966 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:24:31,967 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:24:33,129 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:24:33,129 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:24:34,349 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:24:35,782 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:24:35,783 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:24:35,783 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:24:35,783 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:24:35,968 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:24:37,968 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:24:39,784 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:24:41,622 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:24:41,622 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:24:41,622 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:24:41,623 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:24:41,970 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:24:43,970 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:24:44,197 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:24:45,198 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:24:47,504 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:24:47,505 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:24:47,505 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:24:47,506 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:24:47,971 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:24:48,128 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:24:48,129 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:24:49,972 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:24:50,275 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:24:53,430 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:24:53,431 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:24:53,431 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:24:53,431 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:24:53,973 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:24:53,973 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:24:55,431 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:24:59,306 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:24:59,307 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:24:59,307 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:24:59,307 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:24:59,974 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:24:59,975 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:25:01,308 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:25:03,128 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:25:03,129 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:25:05,242 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:25:05,243 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:25:05,243 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:25:05,243 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:25:05,976 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:25:05,976 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:25:07,243 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:25:11,085 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:25:11,086 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:25:11,086 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:25:11,086 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:25:11,977 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:25:11,978 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:25:13,086 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:25:14,198 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:25:16,962 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:25:16,963 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:25:16,963 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:25:16,963 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:25:16,979 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:25:17,979 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:25:18,129 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:25:18,129 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:25:18,129 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:25:22,847 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:25:22,848 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:25:22,848 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:25:22,848 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:25:22,981 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:25:23,848 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:25:23,981 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:25:28,741 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:25:28,741 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:25:28,741 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:25:28,742 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:25:28,982 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:25:29,742 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:25:29,983 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:25:33,129 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:25:33,129 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:25:34,674 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:25:34,675 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:25:34,675 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:25:34,675 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:25:34,984 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:25:35,675 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:25:35,984 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:25:40,516 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:25:40,516 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:25:40,516 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:25:40,517 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:25:40,986 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:25:41,517 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:25:41,986 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:25:44,199 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:25:46,401 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:25:46,402 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:25:46,402 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:25:46,402 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:25:46,988 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:25:47,402 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:25:47,988 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:25:48,129 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:25:48,129 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:25:52,330 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:25:52,331 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:25:52,331 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:25:52,331 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:25:52,990 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:25:53,331 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:25:53,990 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:25:58,176 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:25:58,176 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:25:58,176 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:25:58,176 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:25:58,991 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:25:59,177 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:25:59,992 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:26:03,129 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:26:03,129 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:26:04,134 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:26:04,135 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:26:04,135 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:26:04,135 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:26:04,993 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:26:05,135 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:26:05,993 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:26:09,981 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:26:09,985 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:26:09,986 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:26:09,986 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:26:09,994 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:26:10,986 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:26:11,995 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:26:14,199 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:26:16,200 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:26:21,200 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:26:24,156 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:26:24,157 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:26:26,333 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:26:28,143 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:26:28,143 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:26:28,144 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:26:28,144 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:26:28,999 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:26:30,000 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:26:32,144 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:26:33,974 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:26:33,975 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:26:33,975 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:26:33,975 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:26:34,001 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:26:36,001 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:26:37,976 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:26:39,156 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:26:39,156 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:26:39,862 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:26:39,863 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:26:39,863 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:26:39,863 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:26:40,002 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:26:42,003 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:26:43,864 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:26:44,200 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:26:45,708 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:26:45,708 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:26:45,708 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:26:45,709 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:26:46,004 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:26:48,005 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:26:49,709 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:26:51,576 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:26:51,577 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:26:51,577 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:26:51,577 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:26:52,006 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:26:52,006 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:26:54,156 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:26:54,157 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:26:55,341 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:26:57,510 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:26:57,511 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:26:57,511 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:26:57,511 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:26:58,008 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:26:58,008 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:27:00,512 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:27:03,357 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:27:03,358 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:27:03,358 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:27:03,358 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:27:04,010 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:27:04,010 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:27:06,359 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:27:09,156 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:27:09,157 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:27:09,278 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:27:09,391 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:27:09,391 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:27:09,391 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:27:10,011 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:27:10,012 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:27:11,392 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:27:14,200 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:27:15,118 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:27:15,119 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:27:15,119 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:27:15,119 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:27:16,013 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:27:16,013 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:27:17,119 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:27:21,008 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:27:21,009 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:27:21,009 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:27:21,009 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:27:21,014 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:27:22,015 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:27:23,010 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:27:24,156 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:27:24,157 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:27:26,926 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:27:26,927 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:27:26,927 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:27:26,927 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:27:27,016 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:27:28,016 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:27:28,927 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:27:32,778 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:27:32,779 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:27:32,779 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:27:32,779 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:27:33,018 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:27:34,018 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:27:34,779 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:27:38,669 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:27:38,670 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:27:38,670 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:27:38,670 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:27:39,020 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:27:39,156 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:27:39,157 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:27:40,020 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:27:40,384 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:27:44,200 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:27:44,622 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:27:44,622 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:27:44,623 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:27:44,623 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:27:45,021 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:27:45,623 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:27:46,022 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:27:50,470 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:27:50,471 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:27:50,471 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:27:50,471 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:27:51,023 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:27:51,471 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:27:52,023 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:27:54,156 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:27:54,157 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:27:56,426 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:27:56,427 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:27:56,427 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:27:56,427 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:27:57,025 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:27:57,427 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:27:58,025 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:28:02,298 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:28:02,298 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:28:02,298 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:28:02,298 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:28:03,026 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:28:03,299 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:28:04,026 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:28:08,183 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:28:08,184 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:28:08,184 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:28:08,185 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:28:09,028 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:28:09,157 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:28:09,157 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:28:09,157 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:28:10,028 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:28:14,122 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:28:14,123 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:28:14,123 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:28:14,123 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:28:14,201 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:28:14,201 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:28:15,029 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:28:16,030 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:28:19,202 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:28:19,972 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:28:19,972 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:28:19,972 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:28:19,973 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:28:20,031 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:28:22,031 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:28:24,157 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:28:24,157 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:28:24,389 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:28:25,902 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:28:25,902 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:28:25,903 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:28:25,903 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:28:26,032 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:28:28,033 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:28:29,904 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:28:31,782 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:28:31,783 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:28:31,783 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:28:31,783 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:28:32,034 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:28:34,034 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:28:35,784 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:28:37,676 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:28:37,677 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:28:37,677 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:28:37,677 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:28:38,035 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:28:38,035 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:28:39,157 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:28:39,157 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:28:41,384 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:28:43,602 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:28:43,602 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:28:43,603 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:28:43,603 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:28:44,036 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:28:44,037 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:28:44,201 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:28:47,202 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:28:49,449 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:28:49,449 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:28:49,450 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:28:49,450 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:28:50,038 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:28:50,038 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:28:52,450 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:28:54,157 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:28:54,157 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:28:55,382 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:28:55,382 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:28:55,383 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:28:55,383 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:28:56,039 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:28:56,040 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:28:58,384 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:29:01,238 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:29:01,239 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:29:01,239 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:29:01,239 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:29:02,041 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:29:02,041 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:29:04,240 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:29:07,127 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:29:07,127 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:29:07,128 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:29:07,128 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:29:08,042 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:29:08,043 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:29:09,157 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:29:09,157 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:29:09,378 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:29:13,066 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:29:13,066 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:29:13,067 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:29:13,067 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:29:14,044 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:29:14,044 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:29:14,202 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:29:15,203 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:29:18,906 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:29:18,907 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:29:18,907 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:29:18,907 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:29:19,045 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:29:20,046 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:29:20,912 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:29:24,169 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:29:24,169 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:29:26,388 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:29:31,389 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:29:34,049 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:29:34,196 DEBUG SenderThread:33547 [sender.py:send():378] send: telemetry +2024-05-25 21:29:34,197 DEBUG SenderThread:33547 [sender.py:send():378] send: exit +2024-05-25 21:29:34,197 INFO SenderThread:33547 [sender.py:send_exit():585] handling exit code: 0 +2024-05-25 21:29:34,197 INFO SenderThread:33547 [sender.py:send_exit():587] handling runtime: 3800 +2024-05-25 21:29:34,197 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:29:34,197 INFO SenderThread:33547 [sender.py:send_exit():593] send defer +2024-05-25 21:29:34,197 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: defer +2024-05-25 21:29:34,198 INFO HandlerThread:33547 [handler.py:handle_request_defer():184] handle defer: 0 +2024-05-25 21:29:34,198 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: defer +2024-05-25 21:29:34,198 INFO SenderThread:33547 [sender.py:send_request_defer():609] handle sender defer: 0 +2024-05-25 21:29:34,198 INFO SenderThread:33547 [sender.py:transition_state():613] send defer: 1 +2024-05-25 21:29:34,198 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: defer +2024-05-25 21:29:34,198 INFO HandlerThread:33547 [handler.py:handle_request_defer():184] handle defer: 1 +2024-05-25 21:29:34,198 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: defer +2024-05-25 21:29:34,198 INFO SenderThread:33547 [sender.py:send_request_defer():609] handle sender defer: 1 +2024-05-25 21:29:34,198 INFO SenderThread:33547 [sender.py:transition_state():613] send defer: 2 +2024-05-25 21:29:34,198 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: defer +2024-05-25 21:29:34,198 INFO HandlerThread:33547 [handler.py:handle_request_defer():184] handle defer: 2 +2024-05-25 21:29:34,198 INFO HandlerThread:33547 [system_monitor.py:finish():203] Stopping system monitor +2024-05-25 21:29:34,198 DEBUG SystemMonitor:33547 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-05-25 21:29:34,198 DEBUG SystemMonitor:33547 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-05-25 21:29:34,199 INFO HandlerThread:33547 [interfaces.py:finish():200] Joined cpu monitor +2024-05-25 21:29:34,199 INFO HandlerThread:33547 [interfaces.py:finish():200] Joined disk monitor +2024-05-25 21:29:34,222 INFO HandlerThread:33547 [interfaces.py:finish():200] Joined gpu monitor +2024-05-25 21:29:34,222 INFO HandlerThread:33547 [interfaces.py:finish():200] Joined memory monitor +2024-05-25 21:29:34,222 INFO HandlerThread:33547 [interfaces.py:finish():200] Joined network monitor +2024-05-25 21:29:34,223 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: defer +2024-05-25 21:29:34,223 INFO SenderThread:33547 [sender.py:send_request_defer():609] handle sender defer: 2 +2024-05-25 21:29:34,223 INFO SenderThread:33547 [sender.py:transition_state():613] send defer: 3 +2024-05-25 21:29:34,223 DEBUG SenderThread:33547 [sender.py:send():378] send: stats +2024-05-25 21:29:34,223 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: defer +2024-05-25 21:29:34,223 INFO HandlerThread:33547 [handler.py:handle_request_defer():184] handle defer: 3 +2024-05-25 21:29:34,224 DEBUG SenderThread:33547 [sender.py:send():378] send: history +2024-05-25 21:29:34,224 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:29:34,255 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:29:34,256 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: defer +2024-05-25 21:29:34,256 INFO SenderThread:33547 [sender.py:send_request_defer():609] handle sender defer: 3 +2024-05-25 21:29:34,256 INFO SenderThread:33547 [sender.py:transition_state():613] send defer: 4 +2024-05-25 21:29:34,256 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: defer +2024-05-25 21:29:34,256 INFO HandlerThread:33547 [handler.py:handle_request_defer():184] handle defer: 4 +2024-05-25 21:29:34,256 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: defer +2024-05-25 21:29:34,256 INFO SenderThread:33547 [sender.py:send_request_defer():609] handle sender defer: 4 +2024-05-25 21:29:34,256 INFO SenderThread:33547 [sender.py:transition_state():613] send defer: 5 +2024-05-25 21:29:34,256 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: defer +2024-05-25 21:29:34,256 INFO HandlerThread:33547 [handler.py:handle_request_defer():184] handle defer: 5 +2024-05-25 21:29:34,256 DEBUG SenderThread:33547 [sender.py:send():378] send: summary +2024-05-25 21:29:34,257 INFO SenderThread:33547 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:29:34,257 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: defer +2024-05-25 21:29:34,257 INFO SenderThread:33547 [sender.py:send_request_defer():609] handle sender defer: 5 +2024-05-25 21:29:34,257 INFO SenderThread:33547 [sender.py:transition_state():613] send defer: 6 +2024-05-25 21:29:34,257 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: defer +2024-05-25 21:29:34,257 INFO HandlerThread:33547 [handler.py:handle_request_defer():184] handle defer: 6 +2024-05-25 21:29:34,257 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: defer +2024-05-25 21:29:34,257 INFO SenderThread:33547 [sender.py:send_request_defer():609] handle sender defer: 6 +2024-05-25 21:29:34,259 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:29:34,406 INFO SenderThread:33547 [sender.py:transition_state():613] send defer: 7 +2024-05-25 21:29:34,406 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: defer +2024-05-25 21:29:34,407 INFO HandlerThread:33547 [handler.py:handle_request_defer():184] handle defer: 7 +2024-05-25 21:29:34,407 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: defer +2024-05-25 21:29:34,407 INFO SenderThread:33547 [sender.py:send_request_defer():609] handle sender defer: 7 +2024-05-25 21:29:35,049 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/config.yaml +2024-05-25 21:29:35,050 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:29:35,197 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: poll_exit +2024-05-25 21:29:35,980 INFO SenderThread:33547 [sender.py:transition_state():613] send defer: 8 +2024-05-25 21:29:35,980 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: poll_exit +2024-05-25 21:29:35,981 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: defer +2024-05-25 21:29:35,981 INFO HandlerThread:33547 [handler.py:handle_request_defer():184] handle defer: 8 +2024-05-25 21:29:35,981 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: defer +2024-05-25 21:29:35,981 INFO SenderThread:33547 [sender.py:send_request_defer():609] handle sender defer: 8 +2024-05-25 21:29:35,981 INFO SenderThread:33547 [job_builder.py:build():432] Attempting to build job artifact +2024-05-25 21:29:35,982 INFO SenderThread:33547 [job_builder.py:_get_source_type():565] is repo sourced job +2024-05-25 21:29:35,982 WARNING SenderThread:33547 [job_builder.py:_log_if_verbose():267] No program path found, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job +2024-05-25 21:29:35,982 INFO SenderThread:33547 [sender.py:transition_state():613] send defer: 9 +2024-05-25 21:29:35,982 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: defer +2024-05-25 21:29:35,982 INFO HandlerThread:33547 [handler.py:handle_request_defer():184] handle defer: 9 +2024-05-25 21:29:35,982 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: defer +2024-05-25 21:29:35,982 INFO SenderThread:33547 [sender.py:send_request_defer():609] handle sender defer: 9 +2024-05-25 21:29:35,982 INFO SenderThread:33547 [dir_watcher.py:finish():358] shutting down directory watcher +2024-05-25 21:29:36,050 INFO Thread-12 :33547 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:29:36,050 INFO SenderThread:33547 [dir_watcher.py:finish():388] scan: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files +2024-05-25 21:29:36,050 INFO SenderThread:33547 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/conda-environment.yaml conda-environment.yaml +2024-05-25 21:29:36,050 INFO SenderThread:33547 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log output.log +2024-05-25 21:29:36,050 INFO SenderThread:33547 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-metadata.json wandb-metadata.json +2024-05-25 21:29:36,051 INFO SenderThread:33547 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/config.yaml config.yaml +2024-05-25 21:29:36,051 INFO SenderThread:33547 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/requirements.txt requirements.txt +2024-05-25 21:29:36,051 INFO SenderThread:33547 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json wandb-summary.json +2024-05-25 21:29:36,052 INFO SenderThread:33547 [sender.py:transition_state():613] send defer: 10 +2024-05-25 21:29:36,052 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: defer +2024-05-25 21:29:36,053 INFO HandlerThread:33547 [handler.py:handle_request_defer():184] handle defer: 10 +2024-05-25 21:29:36,054 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: defer +2024-05-25 21:29:36,054 INFO SenderThread:33547 [sender.py:send_request_defer():609] handle sender defer: 10 +2024-05-25 21:29:36,054 INFO SenderThread:33547 [file_pusher.py:finish():169] shutting down file pusher +2024-05-25 21:29:36,197 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: poll_exit +2024-05-25 21:29:36,198 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: poll_exit +2024-05-25 21:29:36,414 INFO wandb-upload_2:33547 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/config.yaml +2024-05-25 21:29:36,415 INFO wandb-upload_3:33547 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/requirements.txt +2024-05-25 21:29:36,428 INFO wandb-upload_0:33547 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/conda-environment.yaml +2024-05-25 21:29:36,449 INFO wandb-upload_4:33547 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/wandb-summary.json +2024-05-25 21:29:36,661 INFO wandb-upload_1:33547 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/files/output.log +2024-05-25 21:29:36,862 INFO Thread-11 (_thread_body):33547 [sender.py:transition_state():613] send defer: 11 +2024-05-25 21:29:36,862 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: defer +2024-05-25 21:29:36,862 INFO HandlerThread:33547 [handler.py:handle_request_defer():184] handle defer: 11 +2024-05-25 21:29:36,863 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: defer +2024-05-25 21:29:36,863 INFO SenderThread:33547 [sender.py:send_request_defer():609] handle sender defer: 11 +2024-05-25 21:29:36,863 INFO SenderThread:33547 [file_pusher.py:join():175] waiting for file pusher +2024-05-25 21:29:36,863 INFO SenderThread:33547 [sender.py:transition_state():613] send defer: 12 +2024-05-25 21:29:36,863 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: defer +2024-05-25 21:29:36,863 INFO HandlerThread:33547 [handler.py:handle_request_defer():184] handle defer: 12 +2024-05-25 21:29:36,863 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: defer +2024-05-25 21:29:36,863 INFO SenderThread:33547 [sender.py:send_request_defer():609] handle sender defer: 12 +2024-05-25 21:29:36,863 INFO SenderThread:33547 [file_stream.py:finish():601] file stream finish called +2024-05-25 21:29:37,198 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: poll_exit +2024-05-25 21:29:37,310 INFO SenderThread:33547 [file_stream.py:finish():605] file stream finish is done +2024-05-25 21:29:37,310 INFO SenderThread:33547 [sender.py:transition_state():613] send defer: 13 +2024-05-25 21:29:37,310 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: poll_exit +2024-05-25 21:29:37,310 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: defer +2024-05-25 21:29:37,310 INFO HandlerThread:33547 [handler.py:handle_request_defer():184] handle defer: 13 +2024-05-25 21:29:37,310 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: defer +2024-05-25 21:29:37,311 INFO SenderThread:33547 [sender.py:send_request_defer():609] handle sender defer: 13 +2024-05-25 21:29:37,311 INFO SenderThread:33547 [sender.py:transition_state():613] send defer: 14 +2024-05-25 21:29:37,311 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: defer +2024-05-25 21:29:37,311 INFO HandlerThread:33547 [handler.py:handle_request_defer():184] handle defer: 14 +2024-05-25 21:29:37,311 DEBUG SenderThread:33547 [sender.py:send():378] send: final +2024-05-25 21:29:37,311 DEBUG SenderThread:33547 [sender.py:send():378] send: footer +2024-05-25 21:29:37,311 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: defer +2024-05-25 21:29:37,311 INFO SenderThread:33547 [sender.py:send_request_defer():609] handle sender defer: 14 +2024-05-25 21:29:37,311 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: poll_exit +2024-05-25 21:29:37,312 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: poll_exit +2024-05-25 21:29:37,312 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: internal_messages +2024-05-25 21:29:37,312 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: server_info +2024-05-25 21:29:37,312 DEBUG SenderThread:33547 [sender.py:send_request():405] send_request: server_info +2024-05-25 21:29:37,354 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: get_summary +2024-05-25 21:29:37,354 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: sampled_history +2024-05-25 21:29:37,443 DEBUG HandlerThread:33547 [handler.py:handle_request():158] handle_request: shutdown +2024-05-25 21:29:37,443 INFO HandlerThread:33547 [handler.py:finish():882] shutting down handler +2024-05-25 21:29:38,312 INFO WriterThread:33547 [datastore.py:close():296] close: /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/run-sapihyp4.wandb +2024-05-25 21:29:38,443 INFO SenderThread:33547 [sender.py:finish():1545] shutting down sender +2024-05-25 21:29:38,443 INFO SenderThread:33547 [file_pusher.py:finish():169] shutting down file pusher +2024-05-25 21:29:38,443 INFO SenderThread:33547 [file_pusher.py:join():175] waiting for file pusher diff --git a/runs2/wandb/run-20240525_202613-sapihyp4/logs/debug.log b/runs2/wandb/run-20240525_202613-sapihyp4/logs/debug.log new file mode 100644 index 0000000000000000000000000000000000000000..7dd627cd8044666ffd183d97ef8b54745d99f79d --- /dev/null +++ b/runs2/wandb/run-20240525_202613-sapihyp4/logs/debug.log @@ -0,0 +1,36 @@ +2024-05-25 20:26:13,701 INFO MainThread:33493 [wandb_setup.py:_flush():76] Current SDK version is 0.17.0 +2024-05-25 20:26:13,701 INFO MainThread:33493 [wandb_setup.py:_flush():76] Configure stats pid to 33493 +2024-05-25 20:26:13,701 INFO MainThread:33493 [wandb_setup.py:_flush():76] Loading settings from /root/.config/wandb/settings +2024-05-25 20:26:13,701 INFO MainThread:33493 [wandb_setup.py:_flush():76] Loading settings from /root/mistral-finetune/wandb/settings +2024-05-25 20:26:13,701 INFO MainThread:33493 [wandb_setup.py:_flush():76] Loading settings from environment variables: {} +2024-05-25 20:26:13,701 WARNING MainThread:33493 [wandb_setup.py:_flush():76] Could not find program at -m train +2024-05-25 20:26:13,701 INFO MainThread:33493 [wandb_setup.py:_flush():76] Inferring run settings from compute environment: {'program_relpath': None, 'program': '-m train'} +2024-05-25 20:26:13,701 INFO MainThread:33493 [wandb_setup.py:_flush():76] Applying login settings: {'api_key': '***REDACTED***'} +2024-05-25 20:26:13,701 INFO MainThread:33493 [wandb_setup.py:_flush():76] Applying login settings: {'api_key': '***REDACTED***'} +2024-05-25 20:26:13,701 INFO MainThread:33493 [wandb_setup.py:_flush():76] Applying login settings: {} +2024-05-25 20:26:13,701 INFO MainThread:33493 [wandb_init.py:_log_setup():520] Logging user logs to /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/logs/debug.log +2024-05-25 20:26:13,701 INFO MainThread:33493 [wandb_init.py:_log_setup():521] Logging internal logs to /root/mistral-finetune/runs2/wandb/run-20240525_202613-sapihyp4/logs/debug-internal.log +2024-05-25 20:26:13,701 INFO MainThread:33493 [wandb_init.py:init():560] calling init triggers +2024-05-25 20:26:13,701 INFO MainThread:33493 [wandb_init.py:init():567] wandb.init called with sweep_config: {} +config: {'data': {'data': '', 'shuffle': False, 'instruct_data': '/root/data/mol_instructions_train.jsonl', 'eval_instruct_data': '', 'instruct': {'shuffle': True, 'dynamic_chunk_fn_call': True}}, 'model_id_or_path': '/root/mistral_models/7B-v0.3', 'run_dir': '/root/mistral-finetune/runs2', 'optim': {'lr': 6e-05, 'weight_decay': 0.1, 'pct_start': 0.05}, 'seed': 0, 'num_microbatches': 1, 'seq_len': 32768, 'batch_size': 1, 'max_norm': 1.0, 'max_steps': 500, 'log_freq': 1, 'ckpt_freq': 100, 'ckpt_only_lora': False, 'no_ckpt': False, 'num_ckpt_keep': 3, 'eval_freq': 100, 'no_eval': True, 'checkpoint': True, 'world_size': 1, 'wandb': {'project': 'CHEMISTral7b-ft', 'offline': False, 'key': 'aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df', 'run_name': 'run1'}, 'mlflow': {'tracking_uri': None, 'experiment_name': None}, 'lora': {'enable': True, 'rank': 64, 'dropout': 0.0, 'scaling': 2.0}} +2024-05-25 20:26:13,701 INFO MainThread:33493 [wandb_init.py:init():610] starting backend +2024-05-25 20:26:13,701 INFO MainThread:33493 [wandb_init.py:init():614] setting up manager +2024-05-25 20:26:13,702 INFO MainThread:33493 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn +2024-05-25 20:26:13,702 INFO MainThread:33493 [wandb_init.py:init():622] backend started and connected +2024-05-25 20:26:13,704 INFO MainThread:33493 [wandb_init.py:init():711] updated telemetry +2024-05-25 20:26:13,706 INFO MainThread:33493 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout +2024-05-25 20:26:14,054 INFO MainThread:33493 [wandb_run.py:_on_init():2396] communicating current version +2024-05-25 20:26:14,086 INFO MainThread:33493 [wandb_run.py:_on_init():2405] got version response +2024-05-25 20:26:14,087 INFO MainThread:33493 [wandb_init.py:init():795] starting run threads in backend +2024-05-25 20:26:15,147 INFO MainThread:33493 [wandb_run.py:_console_start():2374] atexit reg +2024-05-25 20:26:15,147 INFO MainThread:33493 [wandb_run.py:_redirect():2229] redirect: wrap_raw +2024-05-25 20:26:15,148 INFO MainThread:33493 [wandb_run.py:_redirect():2294] Wrapping output streams. +2024-05-25 20:26:15,148 INFO MainThread:33493 [wandb_run.py:_redirect():2319] Redirects installed. +2024-05-25 20:26:15,148 INFO MainThread:33493 [wandb_init.py:init():838] run started, returning control to user process +2024-05-25 21:29:34,196 INFO MainThread:33493 [wandb_run.py:_finish():2103] finishing run artsy/CHEMISTral7b-ft/sapihyp4 +2024-05-25 21:29:34,196 INFO MainThread:33493 [wandb_run.py:_atexit_cleanup():2343] got exitcode: 0 +2024-05-25 21:29:34,196 INFO MainThread:33493 [wandb_run.py:_restore():2326] restore +2024-05-25 21:29:34,196 INFO MainThread:33493 [wandb_run.py:_restore():2332] restore done +2024-05-25 21:29:38,445 INFO MainThread:33493 [wandb_run.py:_footer_history_summary_info():3994] rendering history +2024-05-25 21:29:38,445 INFO MainThread:33493 [wandb_run.py:_footer_history_summary_info():4026] rendering summary +2024-05-25 21:29:38,448 INFO MainThread:33493 [wandb_run.py:_footer_sync_info():3953] logging synced files diff --git a/runs2/wandb/run-20240525_202613-sapihyp4/run-sapihyp4.wandb b/runs2/wandb/run-20240525_202613-sapihyp4/run-sapihyp4.wandb new file mode 100644 index 0000000000000000000000000000000000000000..5996191bc57a48a2bf105b57b8e7e3e608d6252c Binary files /dev/null and b/runs2/wandb/run-20240525_202613-sapihyp4/run-sapihyp4.wandb differ diff --git a/runseed42/args.yaml b/runseed42/args.yaml new file mode 100644 index 0000000000000000000000000000000000000000..8e5ea2e24103c457cf040999cc9a9f8460229009 --- /dev/null +++ b/runseed42/args.yaml @@ -0,0 +1,42 @@ +batch_size: 2 +checkpoint: true +ckpt_freq: 100 +ckpt_only_lora: false +data: + data: '' + eval_instruct_data: '' + instruct: + dynamic_chunk_fn_call: true + shuffle: true + instruct_data: /root/data/mol_instructions_train.jsonl + shuffle: false +eval_freq: 100 +log_freq: 1 +lora: + dropout: 0.0 + enable: true + rank: 64 + scaling: 2.0 +max_norm: 1.0 +max_steps: 500 +mlflow: + experiment_name: null + tracking_uri: null +model_id_or_path: /root/mistral_models/7B-v0.3 +no_ckpt: false +no_eval: true +num_ckpt_keep: 3 +num_microbatches: 1 +optim: + lr: 6.0e-05 + pct_start: 0.05 + weight_decay: 0.1 +run_dir: /root/mistral-finetune/runseed42 +seed: 42 +seq_len: 32768 +wandb: + key: aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df + offline: false + project: CHEMISTral7b-ft + run_name: runseed42 +world_size: 1 diff --git a/runseed42/checkpoints/checkpoint_000300/consolidated/consolidated.safetensors b/runseed42/checkpoints/checkpoint_000300/consolidated/consolidated.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..9dde048a65f8a0a499b865ddc2cc791849afc8e5 --- /dev/null +++ b/runseed42/checkpoints/checkpoint_000300/consolidated/consolidated.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:3796630769cf80137346f8176a0941f9e48ba5578aa6a5b4938ebb4a62593591 +size 14496078512 diff --git a/runseed42/checkpoints/checkpoint_000300/consolidated/params.json b/runseed42/checkpoints/checkpoint_000300/consolidated/params.json new file mode 100644 index 0000000000000000000000000000000000000000..f6f914db94794fe23c78add929abbca1c57efa3c --- /dev/null +++ b/runseed42/checkpoints/checkpoint_000300/consolidated/params.json @@ -0,0 +1,18 @@ +{ + "dim": 4096, + "n_layers": 32, + "head_dim": 128, + "hidden_dim": 14336, + "n_heads": 32, + "n_kv_heads": 8, + "norm_eps": 1e-05, + "vocab_size": 32768, + "rope_theta": 1000000.0, + "lora": { + "enable": true, + "rank": 64, + "dropout": 0.0, + "scaling": 2.0 + }, + "moe": null +} \ No newline at end of file diff --git a/runseed42/checkpoints/checkpoint_000300/consolidated/tokenizer.model.v3 b/runseed42/checkpoints/checkpoint_000300/consolidated/tokenizer.model.v3 new file mode 100644 index 0000000000000000000000000000000000000000..d8233e5b061987d32b63dbfb38fe86d7d4fc8a18 Binary files /dev/null and b/runseed42/checkpoints/checkpoint_000300/consolidated/tokenizer.model.v3 differ diff --git a/runseed42/checkpoints/checkpoint_000400/consolidated/consolidated.safetensors b/runseed42/checkpoints/checkpoint_000400/consolidated/consolidated.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..c9ad68605d918cf4b89b7f7a43f67b6fc3a9e46a --- /dev/null +++ b/runseed42/checkpoints/checkpoint_000400/consolidated/consolidated.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:7d6621fa621045f183bdee4be1b790ed21fcde92dd77915ce7efc7344d5d1345 +size 14496078512 diff --git a/runseed42/checkpoints/checkpoint_000400/consolidated/params.json b/runseed42/checkpoints/checkpoint_000400/consolidated/params.json new file mode 100644 index 0000000000000000000000000000000000000000..f6f914db94794fe23c78add929abbca1c57efa3c --- /dev/null +++ b/runseed42/checkpoints/checkpoint_000400/consolidated/params.json @@ -0,0 +1,18 @@ +{ + "dim": 4096, + "n_layers": 32, + "head_dim": 128, + "hidden_dim": 14336, + "n_heads": 32, + "n_kv_heads": 8, + "norm_eps": 1e-05, + "vocab_size": 32768, + "rope_theta": 1000000.0, + "lora": { + "enable": true, + "rank": 64, + "dropout": 0.0, + "scaling": 2.0 + }, + "moe": null +} \ No newline at end of file diff --git a/runseed42/checkpoints/checkpoint_000400/consolidated/tokenizer.model.v3 b/runseed42/checkpoints/checkpoint_000400/consolidated/tokenizer.model.v3 new file mode 100644 index 0000000000000000000000000000000000000000..d8233e5b061987d32b63dbfb38fe86d7d4fc8a18 Binary files /dev/null and b/runseed42/checkpoints/checkpoint_000400/consolidated/tokenizer.model.v3 differ diff --git a/runseed42/checkpoints/checkpoint_000500/consolidated/consolidated.safetensors b/runseed42/checkpoints/checkpoint_000500/consolidated/consolidated.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..6493437bca75dfa66a99de64fc5a29b010e14650 --- /dev/null +++ b/runseed42/checkpoints/checkpoint_000500/consolidated/consolidated.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:1d0c1835a7f23033f18b7f78c4ea8b83925d33d64b00551575d61df7c7104150 +size 14496078512 diff --git a/runseed42/checkpoints/checkpoint_000500/consolidated/params.json b/runseed42/checkpoints/checkpoint_000500/consolidated/params.json new file mode 100644 index 0000000000000000000000000000000000000000..f6f914db94794fe23c78add929abbca1c57efa3c --- /dev/null +++ b/runseed42/checkpoints/checkpoint_000500/consolidated/params.json @@ -0,0 +1,18 @@ +{ + "dim": 4096, + "n_layers": 32, + "head_dim": 128, + "hidden_dim": 14336, + "n_heads": 32, + "n_kv_heads": 8, + "norm_eps": 1e-05, + "vocab_size": 32768, + "rope_theta": 1000000.0, + "lora": { + "enable": true, + "rank": 64, + "dropout": 0.0, + "scaling": 2.0 + }, + "moe": null +} \ No newline at end of file diff --git a/runseed42/checkpoints/checkpoint_000500/consolidated/tokenizer.model.v3 b/runseed42/checkpoints/checkpoint_000500/consolidated/tokenizer.model.v3 new file mode 100644 index 0000000000000000000000000000000000000000..d8233e5b061987d32b63dbfb38fe86d7d4fc8a18 Binary files /dev/null and b/runseed42/checkpoints/checkpoint_000500/consolidated/tokenizer.model.v3 differ diff --git a/runseed42/metrics.train.jsonl b/runseed42/metrics.train.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..138fb7bd62d1afb5e4806fedd760bb6aa177d018 --- /dev/null +++ b/runseed42/metrics.train.jsonl @@ -0,0 +1,500 @@ +{"lr": 2.3999999999999974e-06, "step": 1, "loss": 2.0899362564086914, "percent_done": 0.2, "peak_allocated_mem": 63.57235288619995, "allocated_mem": 24.13792896270752, "wps": 87.55304532290906, "avg_wps": 87.55304532290906, "eta_in_seconds": 373516.00825977325, "at": "2024-05-26T00:03:21.270750"} +{"lr": 2.646387992434257e-06, "step": 2, "loss": 2.524580478668213, "percent_done": 0.4, "peak_allocated_mem": 64.8545789718628, "allocated_mem": 24.138355255126953, "wps": 5626.73457304892, "avg_wps": 172.42315402895264, "eta_in_seconds": 189283.90553927422, "at": "2024-05-26T00:03:32.919173"} +{"lr": 3.3813362028748325e-06, "step": 3, "loss": 2.1502745151519775, "percent_done": 0.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5601.028629241724, "avg_wps": 254.71414615069997, "eta_in_seconds": 127874.29552785555, "at": "2024-05-26T00:03:44.621084"} +{"lr": 4.592269463674938e-06, "step": 4, "loss": 2.0348753929138184, "percent_done": 0.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1399564743042, "wps": 5526.5897570007055, "avg_wps": 334.48025845457653, "eta_in_seconds": 97183.18249988556, "at": "2024-05-26T00:03:56.480504"} +{"lr": 6.258468371008163e-06, "step": 5, "loss": 2.400183916091919, "percent_done": 1.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5562.432567416476, "avg_wps": 411.9081073188292, "eta_in_seconds": 78756.20659947395, "at": "2024-05-26T00:04:08.263517"} +{"lr": 8.351423799612423e-06, "step": 6, "loss": 2.1549015045166016, "percent_done": 1.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.138590335845947, "wps": 5558.27034773041, "avg_wps": 487.07063610458806, "eta_in_seconds": 66468.3551012675, "at": "2024-05-26T00:04:20.055323"} +{"lr": 1.0835324701827431e-05, "step": 7, "loss": 2.195272922515869, "percent_done": 1.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1382474899292, "wps": 5542.565544724134, "avg_wps": 560.0464308757615, "eta_in_seconds": 57690.3024798802, "at": "2024-05-26T00:04:31.880537"} +{"lr": 1.3667670844548846e-05, "step": 8, "loss": 2.157195568084717, "percent_done": 1.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5545.683469111278, "avg_wps": 630.9504489538973, "eta_in_seconds": 51103.39814078808, "at": "2024-05-26T00:04:43.699113"} +{"lr": 1.6799999999999995e-05, "step": 9, "loss": 1.9964332580566406, "percent_done": 1.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5545.264269198486, "avg_wps": 699.8652592379805, "eta_in_seconds": 45977.67295241356, "at": "2024-05-26T00:04:55.518644"} +{"lr": 2.017871714788541e-05, "step": 10, "loss": 2.042534351348877, "percent_done": 2.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5535.939583040763, "avg_wps": 766.8561123607292, "eta_in_seconds": 41875.7045583725, "at": "2024-05-26T00:05:07.358144"} +{"lr": 2.37460115010474e-05, "step": 11, "loss": 2.069523811340332, "percent_done": 2.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5536.518620411838, "avg_wps": 832.0175548675699, "eta_in_seconds": 38517.34114564549, "at": "2024-05-26T00:05:19.196394"} +{"lr": 2.7440845664062507e-05, "step": 12, "loss": 2.052086353302002, "percent_done": 2.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.141798496246338, "wps": 5537.652180456069, "avg_wps": 895.4250382708717, "eta_in_seconds": 35716.633590857185, "at": "2024-05-26T00:05:31.032277"} +{"lr": 3.12e-05, "step": 13, "loss": 1.8192474842071533, "percent_done": 2.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14063787460327, "wps": 5535.187561665465, "avg_wps": 957.1407687539536, "eta_in_seconds": 33345.18081551332, "at": "2024-05-26T00:05:42.873465"} +{"lr": 3.495915433593748e-05, "step": 14, "loss": 1.946042537689209, "percent_done": 2.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14157009124756, "wps": 5542.429649320902, "avg_wps": 1017.2536778805361, "eta_in_seconds": 31310.27853972571, "at": "2024-05-26T00:05:54.699126"} +{"lr": 3.86539884989526e-05, "step": 15, "loss": 1.7829875946044922, "percent_done": 3.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5543.334775724542, "avg_wps": 1075.8131015326833, "eta_in_seconds": 29545.057552019753, "at": "2024-05-26T00:06:06.522826"} +{"lr": 4.222128285211459e-05, "step": 16, "loss": 2.223297119140625, "percent_done": 3.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1397123336792, "wps": 5542.737882195839, "avg_wps": 1132.8750127130904, "eta_in_seconds": 27999.049889922142, "at": "2024-05-26T00:06:18.347795"} +{"lr": 4.56e-05, "step": 17, "loss": 1.4540331363677979, "percent_done": 3.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1370267868042, "wps": 5544.523580319454, "avg_wps": 1188.502286267241, "eta_in_seconds": 26633.426259040833, "at": "2024-05-26T00:06:30.168902"} +{"lr": 4.873232915545115e-05, "step": 18, "loss": 1.5981942415237427, "percent_done": 3.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5539.665356843985, "avg_wps": 1242.7306282749407, "eta_in_seconds": 25418.50283665127, "at": "2024-05-26T00:06:42.000450"} +{"lr": 5.156467529817257e-05, "step": 19, "loss": 1.4388254880905151, "percent_done": 3.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13890552520752, "wps": 5535.4164015669085, "avg_wps": 1295.6116764956253, "eta_in_seconds": 24330.450683543557, "at": "2024-05-26T00:06:53.841037"} +{"lr": 5.404857620038757e-05, "step": 20, "loss": 2.101304054260254, "percent_done": 4.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13890504837036, "wps": 5535.553625409448, "avg_wps": 1347.2061159255522, "eta_in_seconds": 23350.012762069702, "at": "2024-05-26T00:07:05.681392"} +{"lr": 5.6141531628991836e-05, "step": 21, "loss": 1.871744990348816, "percent_done": 4.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13712167739868, "wps": 5537.535267234748, "avg_wps": 1397.565993168832, "eta_in_seconds": 22461.72570986975, "at": "2024-05-26T00:07:17.517503"} +{"lr": 5.780773053632506e-05, "step": 22, "loss": 1.5911368131637573, "percent_done": 4.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5540.108387338111, "avg_wps": 1446.7377626459229, "eta_in_seconds": 21652.99669976668, "at": "2024-05-26T00:07:29.348185"} +{"lr": 5.9018663797125166e-05, "step": 23, "loss": 1.609352707862854, "percent_done": 4.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5547.958456519078, "avg_wps": 1494.7807037776133, "eta_in_seconds": 20913.216180137966, "at": "2024-05-26T00:07:41.162052"} +{"lr": 5.975361200756574e-05, "step": 24, "loss": 1.9449068307876587, "percent_done": 4.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5535.518287668786, "avg_wps": 1541.670982436515, "eta_in_seconds": 20234.626165628433, "at": "2024-05-26T00:07:53.002301"} +{"lr": 6e-05, "step": 25, "loss": 1.9009581804275513, "percent_done": 5.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5540.029779982879, "avg_wps": 1587.5003088337653, "eta_in_seconds": 19609.19303560257, "at": "2024-05-26T00:08:04.833075"} +{"lr": 5.9999343854031334e-05, "step": 26, "loss": 2.0498569011688232, "percent_done": 5.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5537.299670855712, "avg_wps": 1632.2818262005753, "eta_in_seconds": 19031.066511539313, "at": "2024-05-26T00:08:16.669672"} +{"lr": 5.999737544482728e-05, "step": 27, "loss": 1.349915862083435, "percent_done": 5.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1389799118042, "wps": 5532.232178571703, "avg_wps": 1676.0420801840273, "eta_in_seconds": 18495.07740079915, "at": "2024-05-26T00:08:28.517110"} +{"lr": 5.999409485849245e-05, "step": 28, "loss": 1.783543586730957, "percent_done": 5.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139604091644287, "wps": 5529.9537137257485, "avg_wps": 1718.823329676492, "eta_in_seconds": 17996.60934659413, "at": "2024-05-26T00:08:40.369421"} +{"lr": 5.9989502238530296e-05, "step": 29, "loss": 1.620679259300232, "percent_done": 5.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13735866546631, "wps": 5522.544560390815, "avg_wps": 1760.6392671318408, "eta_in_seconds": 17531.959315143784, "at": "2024-05-26T00:08:52.237600"} +{"lr": 5.99835977858369e-05, "step": 30, "loss": 1.3995318412780762, "percent_done": 6.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1380033493042, "wps": 5539.8447711905565, "avg_wps": 1801.6069794911675, "eta_in_seconds": 17096.914227485657, "at": "2024-05-26T00:09:04.068718"} +{"lr": 5.9976381758692166e-05, "step": 31, "loss": 1.4312913417816162, "percent_done": 6.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5547.84189151848, "avg_wps": 1841.7244829614674, "eta_in_seconds": 16688.915353167442, "at": "2024-05-26T00:09:15.882864"} +{"lr": 5.9967854472748474e-05, "step": 32, "loss": 1.5339837074279785, "percent_done": 6.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817262649536, "wps": 5519.576169787376, "avg_wps": 1880.8898191051344, "eta_in_seconds": 16306.562823861837, "at": "2024-05-26T00:09:27.757474"} +{"lr": 5.9958016301016944e-05, "step": 33, "loss": 1.7230792045593262, "percent_done": 6.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1387357711792, "wps": 5532.143774040797, "avg_wps": 1919.2757446824705, "eta_in_seconds": 15946.281864289082, "at": "2024-05-26T00:09:39.605130"} +{"lr": 5.994686767385109e-05, "step": 34, "loss": 1.7153072357177734, "percent_done": 6.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963747024536, "wps": 5533.034517617992, "avg_wps": 1956.8662360217147, "eta_in_seconds": 15606.470916523655, "at": "2024-05-26T00:09:51.450911"} +{"lr": 5.993440907892797e-05, "step": 35, "loss": 1.494494915008545, "percent_done": 7.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.138137340545654, "wps": 5540.615145675467, "avg_wps": 1993.7108246045661, "eta_in_seconds": 15285.185606615883, "at": "2024-05-26T00:10:03.280422"} +{"lr": 5.9920641061226885e-05, "step": 36, "loss": 1.7100409269332886, "percent_done": 7.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13980770111084, "wps": 5534.4324016424225, "avg_wps": 2029.782447507116, "eta_in_seconds": 14981.262665536668, "at": "2024-05-26T00:10:15.123147"} +{"lr": 5.9905564223005546e-05, "step": 37, "loss": 1.5540026426315308, "percent_done": 7.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1370267868042, "wps": 5525.468940137315, "avg_wps": 2065.0927280221586, "eta_in_seconds": 14693.3682871767, "at": "2024-05-26T00:10:26.985070"} +{"lr": 5.988917922377368e-05, "step": 38, "loss": 1.7690261602401733, "percent_done": 7.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1406888961792, "wps": 5539.526477800049, "avg_wps": 2099.75008205116, "eta_in_seconds": 14419.636059936724, "at": "2024-05-26T00:10:38.816769"} +{"lr": 5.9871486780264246e-05, "step": 39, "loss": 1.610843300819397, "percent_done": 7.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137158393859863, "wps": 5524.0498246239495, "avg_wps": 2133.6638130239685, "eta_in_seconds": 14159.726483424505, "at": "2024-05-26T00:10:50.681769"} +{"lr": 5.985248766640204e-05, "step": 40, "loss": 1.6625176668167114, "percent_done": 8.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5544.099411977706, "avg_wps": 2166.989231035533, "eta_in_seconds": 13911.725802898407, "at": "2024-05-26T00:11:02.503842"} +{"lr": 5.983218271326983e-05, "step": 41, "loss": 1.5587224960327148, "percent_done": 8.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1389799118042, "wps": 5535.130493970461, "avg_wps": 2199.6351751730604, "eta_in_seconds": 13675.460521599141, "at": "2024-05-26T00:11:14.345102"} +{"lr": 5.981057280907208e-05, "step": 42, "loss": 1.6394068002700806, "percent_done": 8.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5542.058876517238, "avg_wps": 2231.6811301296284, "eta_in_seconds": 13449.72074852671, "at": "2024-05-26T00:11:26.171525"} +{"lr": 5.978765889909597e-05, "step": 43, "loss": 1.8504140377044678, "percent_done": 8.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5537.244232765539, "avg_wps": 2263.099743394272, "eta_in_seconds": 13234.039766660957, "at": "2024-05-26T00:11:38.008052"} +{"lr": 5.976344198567018e-05, "step": 44, "loss": 1.6190497875213623, "percent_done": 8.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1387357711792, "wps": 5530.863783795987, "avg_wps": 2293.901811341495, "eta_in_seconds": 13027.765989043497, "at": "2024-05-26T00:11:49.858501"} +{"lr": 5.9737923128120935e-05, "step": 45, "loss": 1.6997615098953247, "percent_done": 9.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137300491333008, "wps": 5523.228225775809, "avg_wps": 2324.0986163203415, "eta_in_seconds": 12830.298934221268, "at": "2024-05-26T00:12:01.725220"} +{"lr": 5.971110344272575e-05, "step": 46, "loss": 1.7731759548187256, "percent_done": 9.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1370849609375, "wps": 5546.081359300658, "avg_wps": 2353.8257788054875, "eta_in_seconds": 12640.418958746868, "at": "2024-05-26T00:12:13.543067"} +{"lr": 5.968298410266454e-05, "step": 47, "loss": 1.6038544178009033, "percent_done": 9.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1380033493042, "wps": 5530.973292789456, "avg_wps": 2382.9499028627824, "eta_in_seconds": 12458.427247813408, "at": "2024-05-26T00:12:25.393198"} +{"lr": 5.9653566337968336e-05, "step": 48, "loss": 1.5806320905685425, "percent_done": 9.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5538.426185704312, "avg_wps": 2411.5744073380824, "eta_in_seconds": 12283.374674181143, "at": "2024-05-26T00:12:37.227423"} +{"lr": 5.9622851435465466e-05, "step": 49, "loss": 1.4341806173324585, "percent_done": 9.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137271404266357, "wps": 5547.794415919143, "avg_wps": 2439.7212897046975, "eta_in_seconds": 12114.800212928227, "at": "2024-05-26T00:12:49.041635"} +{"lr": 5.9590840738725265e-05, "step": 50, "loss": 1.4500197172164917, "percent_done": 10.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139648914337158, "wps": 5539.750540924846, "avg_wps": 2467.3355744887713, "eta_in_seconds": 11952.650585889816, "at": "2024-05-26T00:13:00.872857"} +{"lr": 5.955753564799931e-05, "step": 51, "loss": 1.5096863508224487, "percent_done": 10.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5539.978083463767, "avg_wps": 2494.463145163946, "eta_in_seconds": 11796.391563069586, "at": "2024-05-26T00:13:12.703674"} +{"lr": 5.9522937620160167e-05, "step": 52, "loss": 1.7216428518295288, "percent_done": 10.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5543.565295984434, "avg_wps": 2521.1301803976307, "eta_in_seconds": 11645.621566185586, "at": "2024-05-26T00:13:24.526852"} +{"lr": 5.9487048168637646e-05, "step": 53, "loss": 1.7031399011611938, "percent_done": 10.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5537.898963882401, "avg_wps": 2547.312209734005, "eta_in_seconds": 11500.196908748374, "at": "2024-05-26T00:13:36.362193"} +{"lr": 5.944986886335264e-05, "step": 54, "loss": 1.7923967838287354, "percent_done": 10.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13988208770752, "wps": 5540.3491362407385, "avg_wps": 2573.05348120662, "eta_in_seconds": 11359.676825020048, "at": "2024-05-26T00:13:48.192136"} +{"lr": 5.941140133064838e-05, "step": 55, "loss": 1.6145018339157104, "percent_done": 11.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13819980621338, "wps": 5532.177287264699, "avg_wps": 2598.3230307292242, "eta_in_seconds": 11223.97779456052, "at": "2024-05-26T00:14:00.039674"} +{"lr": 5.937164725321938e-05, "step": 56, "loss": 1.493621587753296, "percent_done": 11.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13995599746704, "wps": 5519.523524306861, "avg_wps": 2623.1137353743584, "eta_in_seconds": 11092.917401024273, "at": "2024-05-26T00:14:11.914303"} +{"lr": 5.933060837003778e-05, "step": 57, "loss": 1.4488284587860107, "percent_done": 11.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5551.856517024938, "avg_wps": 2647.6169631340003, "eta_in_seconds": 10965.501582840032, "at": "2024-05-26T00:14:23.719679"} +{"lr": 5.928828647627726e-05, "step": 58, "loss": 1.8310798406600952, "percent_done": 11.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5531.945041172631, "avg_wps": 2671.6337960073306, "eta_in_seconds": 10842.39615597396, "at": "2024-05-26T00:14:35.567699"} +{"lr": 5.924468342323457e-05, "step": 59, "loss": 1.8137357234954834, "percent_done": 11.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13896083831787, "wps": 5527.583975032376, "avg_wps": 2695.2364115035157, "eta_in_seconds": 10723.13206984229, "at": "2024-05-26T00:14:47.424891"} +{"lr": 5.919980111824851e-05, "step": 60, "loss": 1.512571930885315, "percent_done": 12.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5537.72079118129, "avg_wps": 2718.492891536368, "eta_in_seconds": 10607.289093812307, "at": "2024-05-26T00:14:59.260447"} +{"lr": 5.915364152461648e-05, "step": 61, "loss": 1.5166411399841309, "percent_done": 12.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5539.386712673805, "avg_wps": 2741.3785934414523, "eta_in_seconds": 10494.830618737173, "at": "2024-05-26T00:15:11.092581"} +{"lr": 5.9106206661508645e-05, "step": 62, "loss": 1.6018924713134766, "percent_done": 12.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13873529434204, "wps": 5532.074856095626, "avg_wps": 2763.8665452701775, "eta_in_seconds": 10385.72866302921, "at": "2024-05-26T00:15:22.940259"} +{"lr": 5.90574986038796e-05, "step": 63, "loss": 1.4618632793426514, "percent_done": 12.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5529.793850942314, "avg_wps": 2785.985783546574, "eta_in_seconds": 10279.748076654616, "at": "2024-05-26T00:15:34.792730"} +{"lr": 5.9007519482377565e-05, "step": 64, "loss": 1.7917994260787964, "percent_done": 12.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1380033493042, "wps": 5531.270235335729, "avg_wps": 2807.7599972922703, "eta_in_seconds": 10176.687475979328, "at": "2024-05-26T00:15:46.642121"} +{"lr": 5.8956271483251227e-05, "step": 65, "loss": 1.5388588905334473, "percent_done": 13.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13727045059204, "wps": 5541.480467211162, "avg_wps": 2829.2325455082782, "eta_in_seconds": 10076.287311645654, "at": "2024-05-26T00:15:58.469684"} +{"lr": 5.8903756848254094e-05, "step": 66, "loss": 1.5354622602462769, "percent_done": 13.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817262649536, "wps": 5534.298576151526, "avg_wps": 2850.3415745242264, "eta_in_seconds": 9978.672119234547, "at": "2024-05-26T00:16:10.312548"} +{"lr": 5.884997787454641e-05, "step": 67, "loss": 1.551658272743225, "percent_done": 13.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5545.073876931426, "avg_wps": 2871.1669062811698, "eta_in_seconds": 9883.468612681574, "at": "2024-05-26T00:16:22.132505"} +{"lr": 5.879493691459472e-05, "step": 68, "loss": 1.5081156492233276, "percent_done": 13.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1384916305542, "wps": 5543.528178915346, "avg_wps": 2891.6666401015896, "eta_in_seconds": 9790.7385337493, "at": "2024-05-26T00:16:33.955697"} +{"lr": 5.873863637606892e-05, "step": 69, "loss": 1.6811738014221191, "percent_done": 13.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13744831085205, "wps": 5540.486158061833, "avg_wps": 2911.8420897351943, "eta_in_seconds": 9700.394159275553, "at": "2024-05-26T00:16:45.785296"} +{"lr": 5.868107872173695e-05, "step": 70, "loss": 2.0245096683502197, "percent_done": 14.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139193534851074, "wps": 5534.936784672989, "avg_wps": 2931.690300093053, "eta_in_seconds": 9612.36594435147, "at": "2024-05-26T00:16:57.627088"} +{"lr": 5.862226646935706e-05, "step": 71, "loss": 1.291055679321289, "percent_done": 14.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5535.811816409992, "avg_wps": 2951.2438980309184, "eta_in_seconds": 9526.472555778397, "at": "2024-05-26T00:17:09.466927"} +{"lr": 5.856220219156771e-05, "step": 72, "loss": 1.696504831314087, "percent_done": 14.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1387357711792, "wps": 5533.233106007674, "avg_wps": 2970.4957223928614, "eta_in_seconds": 9442.669042931664, "at": "2024-05-26T00:17:21.312194"} +{"lr": 5.8500888515774985e-05, "step": 73, "loss": 1.2231526374816895, "percent_done": 14.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1399564743042, "wps": 5514.1967865476645, "avg_wps": 2989.3862016528365, "eta_in_seconds": 9361.076191670274, "at": "2024-05-26T00:17:33.198309"} +{"lr": 5.84383281240377e-05, "step": 74, "loss": 1.5708428621292114, "percent_done": 14.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5538.367712134215, "avg_wps": 3008.094949394964, "eta_in_seconds": 9281.068739407772, "at": "2024-05-26T00:17:45.032506"} +{"lr": 5.8374523752950034e-05, "step": 75, "loss": 1.6024234294891357, "percent_done": 15.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5545.841902233415, "avg_wps": 3026.5607851097043, "eta_in_seconds": 9202.788900534313, "at": "2024-05-26T00:17:56.850793"} +{"lr": 5.830947819352191e-05, "step": 76, "loss": 1.9813722372055054, "percent_done": 15.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5544.453011562738, "avg_wps": 3044.7543202052316, "eta_in_seconds": 9126.274594833976, "at": "2024-05-26T00:18:08.672042"} +{"lr": 5.8243194291056786e-05, "step": 77, "loss": 1.57261323928833, "percent_done": 15.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5534.243420984151, "avg_wps": 3062.646287207252, "eta_in_seconds": 9051.560448163516, "at": "2024-05-26T00:18:20.515204"} +{"lr": 5.817567494502731e-05, "step": 78, "loss": 1.5319303274154663, "percent_done": 15.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5548.882527821081, "avg_wps": 3080.3408991020083, "eta_in_seconds": 8978.289386107372, "at": "2024-05-26T00:18:32.342630"} +{"lr": 5.810692310894839e-05, "step": 79, "loss": 1.504271149635315, "percent_done": 15.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1404447555542, "wps": 5547.128611462899, "avg_wps": 3097.778503134207, "eta_in_seconds": 8906.594184214555, "at": "2024-05-26T00:18:44.158288"} +{"lr": 5.8036941790248074e-05, "step": 80, "loss": 1.537473201751709, "percent_done": 16.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139437198638916, "wps": 5547.05663309866, "avg_wps": 3114.971022758016, "eta_in_seconds": 8836.396807193756, "at": "2024-05-26T00:18:55.974075"} +{"lr": 5.796573405013595e-05, "step": 81, "loss": 1.5852731466293335, "percent_done": 16.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13890552520752, "wps": 5529.699072362179, "avg_wps": 3131.8553361215204, "eta_in_seconds": 8767.83281887019, "at": "2024-05-26T00:19:07.826949"} +{"lr": 5.7893303003469235e-05, "step": 82, "loss": 1.5945942401885986, "percent_done": 16.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139241218566895, "wps": 5530.273912078115, "avg_wps": 3148.507443738734, "eta_in_seconds": 8700.645778836273, "at": "2024-05-26T00:19:19.678572"} +{"lr": 5.7819651818616575e-05, "step": 83, "loss": 1.7726037502288818, "percent_done": 16.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5544.20799199795, "avg_wps": 3164.984762706722, "eta_in_seconds": 8634.642517718925, "at": "2024-05-26T00:19:31.500393"} +{"lr": 5.774478371731938e-05, "step": 84, "loss": 1.5255744457244873, "percent_done": 16.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13762378692627, "wps": 5534.432735935683, "avg_wps": 3181.1985906088116, "eta_in_seconds": 8570.032716751099, "at": "2024-05-26T00:19:43.343105"} +{"lr": 5.766870197455095e-05, "step": 85, "loss": 1.5827147960662842, "percent_done": 17.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13866138458252, "wps": 5523.826585731917, "avg_wps": 3197.150307066719, "eta_in_seconds": 8506.775530660854, "at": "2024-05-26T00:19:55.208549"} +{"lr": 5.759140991837317e-05, "step": 86, "loss": 1.3610950708389282, "percent_done": 17.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13801145553589, "wps": 5541.5615735421, "avg_wps": 3212.9557960341403, "eta_in_seconds": 8444.530744397363, "at": "2024-05-26T00:20:07.036006"} +{"lr": 5.751291092979098e-05, "step": 87, "loss": 1.4847681522369385, "percent_done": 17.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5531.706357934675, "avg_wps": 3228.511079960922, "eta_in_seconds": 8383.5450242059, "at": "2024-05-26T00:20:18.884533"} +{"lr": 5.743320844260443e-05, "step": 88, "loss": 1.0767104625701904, "percent_done": 17.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1387357711792, "wps": 5531.295612714277, "avg_wps": 3243.8574449359435, "eta_in_seconds": 8323.680204304783, "at": "2024-05-26T00:20:30.733993"} +{"lr": 5.735230594325853e-05, "step": 89, "loss": 1.5505489110946655, "percent_done": 17.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5531.027047266254, "avg_wps": 3258.999571955979, "eta_in_seconds": 8264.89706589131, "at": "2024-05-26T00:20:42.583973"} +{"lr": 5.727020697069067e-05, "step": 90, "loss": 1.7600947618484497, "percent_done": 18.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.138655185699463, "wps": 5529.237685026854, "avg_wps": 3273.935553483542, "eta_in_seconds": 8207.174381123648, "at": "2024-05-26T00:20:54.437824"} +{"lr": 5.718691511617588e-05, "step": 91, "loss": 1.317226529121399, "percent_done": 18.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13856601715088, "wps": 5502.959403593815, "avg_wps": 3288.573649336026, "eta_in_seconds": 8150.71421782263, "at": "2024-05-26T00:21:06.348233"} +{"lr": 5.7102434023169716e-05, "step": 92, "loss": 1.2027145624160767, "percent_done": 18.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13890552520752, "wps": 5531.824695043968, "avg_wps": 3303.1331918472656, "eta_in_seconds": 8094.946963082189, "at": "2024-05-26T00:21:18.196493"} +{"lr": 5.701676738714885e-05, "step": 93, "loss": 1.7757294178009033, "percent_done": 18.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13897943496704, "wps": 5513.260013664116, "avg_wps": 3317.4329246403618, "eta_in_seconds": 8040.29881113319, "at": "2024-05-26T00:21:30.084656"} +{"lr": 5.6929918955449466e-05, "step": 94, "loss": 1.6398133039474487, "percent_done": 18.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13995599746704, "wps": 5503.530239684291, "avg_wps": 3331.5109429036474, "eta_in_seconds": 7986.651239034977, "at": "2024-05-26T00:21:41.993855"} +{"lr": 5.6841892527103325e-05, "step": 95, "loss": 1.6421366930007935, "percent_done": 19.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5539.134773708763, "avg_wps": 3345.546401059732, "eta_in_seconds": 7933.556082675331, "at": "2024-05-26T00:21:53.826550"} +{"lr": 5.675269195267157e-05, "step": 96, "loss": 1.535171389579773, "percent_done": 19.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13759183883667, "wps": 5519.26064443039, "avg_wps": 3359.3280993101475, "eta_in_seconds": 7881.499876548847, "at": "2024-05-26T00:22:05.701819"} +{"lr": 5.6662321134076275e-05, "step": 97, "loss": 1.289878249168396, "percent_done": 19.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13732147216797, "wps": 5544.5440467133, "avg_wps": 3373.033047095898, "eta_in_seconds": 7830.047210103458, "at": "2024-05-26T00:22:17.522970"} +{"lr": 5.657078402442983e-05, "step": 98, "loss": 1.6153517961502075, "percent_done": 19.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137089729309082, "wps": 5523.603253886858, "avg_wps": 3386.4871425174815, "eta_in_seconds": 7779.587192058563, "at": "2024-05-26T00:22:29.388874"} +{"lr": 5.6478084627861946e-05, "step": 99, "loss": 1.7160063982009888, "percent_done": 19.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5532.454204423485, "avg_wps": 3399.8077610196756, "eta_in_seconds": 7729.829992539955, "at": "2024-05-26T00:22:41.235797"} +{"lr": 5.638422699934453e-05, "step": 100, "loss": 1.4796698093414307, "percent_done": 20.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139036655426025, "wps": 5539.2885910522355, "avg_wps": 3412.9900073928015, "eta_in_seconds": 7680.772561073303, "at": "2024-05-26T00:22:53.068126"} +{"lr": 5.62892152445143e-05, "step": 101, "loss": 1.5540027618408203, "percent_done": 20.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5597.059642797446, "avg_wps": 3426.227366541052, "eta_in_seconds": 7631.969861474368, "at": "2024-05-26T00:23:19.492117"} +{"lr": 5.619305351949323e-05, "step": 102, "loss": 1.1712055206298828, "percent_done": 20.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137778759002686, "wps": 5565.942533352121, "avg_wps": 3439.18940091804, "eta_in_seconds": 7584.149914231954, "at": "2024-05-26T00:23:31.267769"} +{"lr": 5.609574603070667e-05, "step": 103, "loss": 1.5182369947433472, "percent_done": 20.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14134693145752, "wps": 5553.062441781844, "avg_wps": 3451.947126415252, "eta_in_seconds": 7537.135143497616, "at": "2024-05-26T00:23:43.070636"} +{"lr": 5.599729703469942e-05, "step": 104, "loss": 1.539081335067749, "percent_done": 20.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5539.45056615357, "avg_wps": 3464.5007130604386, "eta_in_seconds": 7490.907968979616, "at": "2024-05-26T00:23:54.902547"} +{"lr": 5.589771083794951e-05, "step": 105, "loss": 1.3853428363800049, "percent_done": 21.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13897943496704, "wps": 5532.474693163494, "avg_wps": 3476.8780093736523, "eta_in_seconds": 7445.3920816921045, "at": "2024-05-26T00:24:06.749359"} +{"lr": 5.579699179667977e-05, "step": 106, "loss": 1.746046781539917, "percent_done": 21.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1397123336792, "wps": 5529.919893688251, "avg_wps": 3489.098434826783, "eta_in_seconds": 7400.531822852368, "at": "2024-05-26T00:24:18.601620"} +{"lr": 5.569514431666738e-05, "step": 107, "loss": 1.4366753101348877, "percent_done": 21.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 3110.3677494049234, "avg_wps": 3485.1324206697495, "eta_in_seconds": 7390.149036302745, "at": "2024-05-26T00:24:39.672844"} +{"lr": 5.559217285305104e-05, "step": 108, "loss": 1.4705623388290405, "percent_done": 21.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1406888961792, "wps": 5568.263503384901, "avg_wps": 3497.246748995588, "eta_in_seconds": 7345.810531492587, "at": "2024-05-26T00:24:51.443525"} +{"lr": 5.548808191013616e-05, "step": 109, "loss": 1.511877417564392, "percent_done": 21.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5544.419461278335, "avg_wps": 3509.133737064294, "eta_in_seconds": 7302.251187906352, "at": "2024-05-26T00:25:03.264777"} +{"lr": 5.538287604119777e-05, "step": 110, "loss": 1.631191611289978, "percent_done": 22.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5539.096934612043, "avg_wps": 3520.863946254514, "eta_in_seconds": 7259.309189493007, "at": "2024-05-26T00:25:15.097574"} +{"lr": 5.5276559848281426e-05, "step": 111, "loss": 1.1168304681777954, "percent_done": 22.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139692783355713, "wps": 5535.312512817423, "avg_wps": 3532.4454920385933, "eta_in_seconds": 7216.956088199272, "at": "2024-05-26T00:25:26.938291"} +{"lr": 5.516913798200181e-05, "step": 112, "loss": 1.3504208326339722, "percent_done": 22.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137049674987793, "wps": 5524.111104691364, "avg_wps": 3543.853551182154, "eta_in_seconds": 7175.231039532594, "at": "2024-05-26T00:25:38.803137"} +{"lr": 5.506061514133933e-05, "step": 113, "loss": 1.6625151634216309, "percent_done": 22.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13819980621338, "wps": 5537.484732799822, "avg_wps": 3555.1805667044105, "eta_in_seconds": 7133.936384983822, "at": "2024-05-26T00:25:50.639233"} +{"lr": 5.495099607343464e-05, "step": 114, "loss": 1.089699625968933, "percent_done": 22.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5526.334425393153, "avg_wps": 3566.3389461793854, "eta_in_seconds": 7093.239420526906, "at": "2024-05-26T00:26:02.499237"} +{"lr": 5.4840285573380864e-05, "step": 115, "loss": 1.5184028148651123, "percent_done": 23.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1370267868042, "wps": 5530.564993204644, "avg_wps": 3577.387108918421, "eta_in_seconds": 7053.013619101566, "at": "2024-05-26T00:26:14.350294"} +{"lr": 5.4728488484013935e-05, "step": 116, "loss": 1.607438325881958, "percent_done": 23.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5537.610457041481, "avg_wps": 3588.337217255435, "eta_in_seconds": 7013.227151278791, "at": "2024-05-26T00:26:26.186115"} +{"lr": 5.46156096957007e-05, "step": 117, "loss": 1.5858045816421509, "percent_done": 23.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1404447555542, "wps": 5532.53783061558, "avg_wps": 3599.147335569262, "eta_in_seconds": 6973.954011813188, "at": "2024-05-26T00:26:38.032820"} +{"lr": 5.450165414612506e-05, "step": 118, "loss": 1.2271007299423218, "percent_done": 23.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5536.211859357799, "avg_wps": 3609.851152518804, "eta_in_seconds": 6935.120297836044, "at": "2024-05-26T00:26:49.871724"} +{"lr": 5.43866268200719e-05, "step": 119, "loss": 1.3237642049789429, "percent_done": 23.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13933229446411, "wps": 5533.040977363736, "avg_wps": 3620.42592349851, "eta_in_seconds": 6896.762018506266, "at": "2024-05-26T00:27:01.717493"} +{"lr": 5.42705327492091e-05, "step": 120, "loss": 1.3115874528884888, "percent_done": 24.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5538.231129826692, "avg_wps": 3630.903646067428, "eta_in_seconds": 6858.810485641161, "at": "2024-05-26T00:27:13.552094"} +{"lr": 5.415337701186742e-05, "step": 121, "loss": 1.2221430540084839, "percent_done": 24.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137965202331543, "wps": 5531.733075183824, "avg_wps": 3641.244261196932, "eta_in_seconds": 6821.334197402985, "at": "2024-05-26T00:27:25.400449"} +{"lr": 5.403516473281833e-05, "step": 122, "loss": 1.6666512489318848, "percent_done": 24.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5535.974926160593, "avg_wps": 3651.4881163845907, "eta_in_seconds": 6784.2499305537485, "at": "2024-05-26T00:27:37.239789"} +{"lr": 5.391590108304989e-05, "step": 123, "loss": 1.5952054262161255, "percent_done": 24.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13706350326538, "wps": 5528.6313692000795, "avg_wps": 3661.595646751923, "eta_in_seconds": 6747.624364781186, "at": "2024-05-26T00:27:49.094976"} +{"lr": 5.3795591279540496e-05, "step": 124, "loss": 1.6903510093688965, "percent_done": 24.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5532.742396950077, "avg_wps": 3671.6095225837266, "eta_in_seconds": 6711.371633729626, "at": "2024-05-26T00:28:00.941314"} +{"lr": 5.3674240585030686e-05, "step": 125, "loss": 1.670830488204956, "percent_done": 25.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1413631439209, "wps": 5535.899446291045, "avg_wps": 3681.5279621076993, "eta_in_seconds": 6675.489159107208, "at": "2024-05-26T00:28:12.780885"} +{"lr": 5.3551854307792975e-05, "step": 126, "loss": 1.5355591773986816, "percent_done": 25.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13866138458252, "wps": 5526.040789881656, "avg_wps": 3691.3065729857167, "eta_in_seconds": 6640.051026749232, "at": "2024-05-26T00:28:24.641450"} +{"lr": 5.3428437801399596e-05, "step": 127, "loss": 1.3291274309158325, "percent_done": 25.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137056350708008, "wps": 5527.882332433383, "avg_wps": 3700.9885506962646, "eta_in_seconds": 6604.972608035005, "at": "2024-05-26T00:28:36.498128"} +{"lr": 5.3303996464488364e-05, "step": 128, "loss": 1.2499892711639404, "percent_done": 25.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5533.640351464532, "avg_wps": 3710.589229455752, "eta_in_seconds": 6570.221194647253, "at": "2024-05-26T00:28:48.342491"} +{"lr": 5.317853574052649e-05, "step": 129, "loss": 1.5997017621994019, "percent_done": 25.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5532.302993307046, "avg_wps": 3720.085156146638, "eta_in_seconds": 6535.833181083665, "at": "2024-05-26T00:29:00.189835"} +{"lr": 5.3052061117572476e-05, "step": 130, "loss": 1.2660155296325684, "percent_done": 26.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13866090774536, "wps": 5522.46223457303, "avg_wps": 3729.448136686874, "eta_in_seconds": 6501.8520465447355, "at": "2024-05-26T00:29:12.058235"} +{"lr": 5.292457812803603e-05, "step": 131, "loss": 1.473204255104065, "percent_done": 26.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.138676643371582, "wps": 5522.268745279879, "avg_wps": 3738.713665425786, "eta_in_seconds": 6468.209701008469, "at": "2024-05-26T00:29:23.926912"} +{"lr": 5.2796092348436136e-05, "step": 132, "loss": 1.4274117946624756, "percent_done": 26.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13702630996704, "wps": 5536.678649211735, "avg_wps": 3747.934068843009, "eta_in_seconds": 6434.811167167894, "at": "2024-05-26T00:29:35.764812"} +{"lr": 5.266660939915699e-05, "step": 133, "loss": 1.4024438858032227, "percent_done": 26.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5533.322659221424, "avg_wps": 3757.04875984181, "eta_in_seconds": 6401.756681223561, "at": "2024-05-26T00:29:47.609838"} +{"lr": 5.25361349442023e-05, "step": 134, "loss": 1.6963635683059692, "percent_done": 26.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13713550567627, "wps": 5533.485845105383, "avg_wps": 3766.0714237744305, "eta_in_seconds": 6369.017817500812, "at": "2024-05-26T00:29:59.454640"} +{"lr": 5.240467469094738e-05, "step": 135, "loss": 1.2273313999176025, "percent_done": 27.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1382474899292, "wps": 5538.345394303255, "avg_wps": 3775.019635857367, "eta_in_seconds": 6336.560417537336, "at": "2024-05-26T00:30:11.288854"} +{"lr": 5.227223438988959e-05, "step": 136, "loss": 1.3269773721694946, "percent_done": 27.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13995599746704, "wps": 5519.251778766513, "avg_wps": 3783.812183740026, "eta_in_seconds": 6304.515880178003, "at": "2024-05-26T00:30:23.164105"} +{"lr": 5.2138819834396735e-05, "step": 137, "loss": 1.6708487272262573, "percent_done": 27.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137944221496582, "wps": 5534.977353276828, "avg_wps": 3792.5705754854494, "eta_in_seconds": 6272.676414717724, "at": "2024-05-26T00:30:35.005563"} +{"lr": 5.200443686045369e-05, "step": 138, "loss": 1.2962806224822998, "percent_done": 27.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13866138458252, "wps": 5535.8934258287845, "avg_wps": 3801.2449240334345, "eta_in_seconds": 6241.121652015741, "at": "2024-05-26T00:30:46.845093"} +{"lr": 5.1869091346407056e-05, "step": 139, "loss": 1.3293571472167969, "percent_done": 27.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1399564743042, "wps": 5518.765651525683, "avg_wps": 3809.774835881176, "eta_in_seconds": 6209.945999217548, "at": "2024-05-26T00:30:58.721325"} +{"lr": 5.1732789212708097e-05, "step": 140, "loss": 1.4928131103515625, "percent_done": 28.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5544.100977467862, "avg_wps": 3818.306670118135, "eta_in_seconds": 6178.9065254075185, "at": "2024-05-26T00:31:10.543196"} +{"lr": 5.159553642165368e-05, "step": 141, "loss": 1.5970425605773926, "percent_done": 28.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5524.360790615043, "avg_wps": 3826.6880343733033, "eta_in_seconds": 6148.247201931392, "at": "2024-05-26T00:31:22.407369"} +{"lr": 5.145733897712554e-05, "step": 142, "loss": 1.7108588218688965, "percent_done": 28.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13866138458252, "wps": 5533.329008253335, "avg_wps": 3835.017837137935, "eta_in_seconds": 6117.804139734993, "at": "2024-05-26T00:31:34.252317"} +{"lr": 5.131820292432759e-05, "step": 143, "loss": 1.868727445602417, "percent_done": 28.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5528.080773501194, "avg_wps": 3843.2490002472596, "eta_in_seconds": 6087.649277602042, "at": "2024-05-26T00:31:46.108465"} +{"lr": 5.117813434952152e-05, "step": 144, "loss": 1.8097214698791504, "percent_done": 28.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5537.813502032706, "avg_wps": 3851.433264880849, "eta_in_seconds": 6057.697068969408, "at": "2024-05-26T00:31:57.943884"} +{"lr": 5.103713937976054e-05, "step": 145, "loss": 1.6488709449768066, "percent_done": 29.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5535.326557634993, "avg_wps": 3859.5305195212936, "eta_in_seconds": 6028.007780305271, "at": "2024-05-26T00:32:09.784516"} +{"lr": 5.0895224182621414e-05, "step": 146, "loss": 1.6172908544540405, "percent_done": 29.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5533.640685662114, "avg_wps": 3867.54463427126, "eta_in_seconds": 5998.5717538774825, "at": "2024-05-26T00:32:21.628812"} +{"lr": 5.075239496593458e-05, "step": 147, "loss": 1.806726336479187, "percent_done": 29.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13849115371704, "wps": 5530.702533019881, "avg_wps": 3875.4725772056986, "eta_in_seconds": 5969.390194132215, "at": "2024-05-26T00:32:33.479389"} +{"lr": 5.0608657977512685e-05, "step": 148, "loss": 1.3950109481811523, "percent_done": 29.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5533.683463286032, "avg_wps": 3883.3352212573154, "eta_in_seconds": 5940.427669937546, "at": "2024-05-26T00:32:45.323748"} +{"lr": 5.0464019504877256e-05, "step": 149, "loss": 1.685523509979248, "percent_done": 29.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13904047012329, "wps": 5525.507592916948, "avg_wps": 3891.096482327046, "eta_in_seconds": 5911.736217407572, "at": "2024-05-26T00:32:57.185460"} +{"lr": 5.031848587498364e-05, "step": 150, "loss": 1.3426657915115356, "percent_done": 30.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5540.3617549189175, "avg_wps": 3898.8338968788635, "eta_in_seconds": 5883.194977442424, "at": "2024-05-26T00:33:09.015393"} +{"lr": 5.017206345394427e-05, "step": 151, "loss": 1.1932377815246582, "percent_done": 30.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5530.696301294541, "avg_wps": 3906.4671727362975, "eta_in_seconds": 5854.922872417021, "at": "2024-05-26T00:33:20.866100"} +{"lr": 5.00247586467502e-05, "step": 152, "loss": 1.5188419818878174, "percent_done": 30.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5534.958963588762, "avg_wps": 3914.0434039079178, "eta_in_seconds": 5826.84596119429, "at": "2024-05-26T00:33:32.707611"} +{"lr": 4.987657789699088e-05, "step": 153, "loss": 1.699030876159668, "percent_done": 30.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13727045059204, "wps": 5534.990616218613, "avg_wps": 3921.5495715785733, "eta_in_seconds": 5798.981138684392, "at": "2024-05-26T00:33:44.549171"} +{"lr": 4.9727527686572356e-05, "step": 154, "loss": 1.4579997062683105, "percent_done": 30.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1389799118042, "wps": 5533.561593359805, "avg_wps": 3928.9818647318493, "eta_in_seconds": 5771.331296676165, "at": "2024-05-26T00:33:56.393598"} +{"lr": 4.957761453543368e-05, "step": 155, "loss": 1.5616415739059448, "percent_done": 31.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13918399810791, "wps": 5546.354522258468, "avg_wps": 3936.387607590215, "eta_in_seconds": 5743.824606195573, "at": "2024-05-26T00:34:08.210887"} +{"lr": 4.942684500126173e-05, "step": 156, "loss": 1.636575698852539, "percent_done": 31.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5536.919434711029, "avg_wps": 3943.6952090659074, "eta_in_seconds": 5716.563477870745, "at": "2024-05-26T00:34:20.048148"} +{"lr": 4.927522567920438e-05, "step": 157, "loss": 1.8378536701202393, "percent_done": 31.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5541.3607112397085, "avg_wps": 3950.9507768392773, "eta_in_seconds": 5689.478120500115, "at": "2024-05-26T00:34:31.876008"} +{"lr": 4.9122763201581924e-05, "step": 158, "loss": 1.624532699584961, "percent_done": 31.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963747024536, "wps": 5538.455646138669, "avg_wps": 3958.1313564214447, "eta_in_seconds": 5662.599338356453, "at": "2024-05-26T00:34:43.710158"} +{"lr": 4.8969464237597066e-05, "step": 159, "loss": 1.4007322788238525, "percent_done": 31.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13916015625, "wps": 5547.36918723339, "avg_wps": 3965.2759596814326, "eta_in_seconds": 5635.869035908261, "at": "2024-05-26T00:34:55.525135"} +{"lr": 4.8815335493043095e-05, "step": 160, "loss": 1.5568217039108276, "percent_done": 32.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14060926437378, "wps": 5542.0574239184625, "avg_wps": 3972.3395722173827, "eta_in_seconds": 5609.349249958991, "at": "2024-05-26T00:35:07.351538"} +{"lr": 4.866038371001062e-05, "step": 161, "loss": 1.3363252878189087, "percent_done": 32.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5545.6341284409145, "avg_wps": 3979.351626452097, "eta_in_seconds": 5582.9959464547055, "at": "2024-05-26T00:35:19.170367"} +{"lr": 4.850461566659259e-05, "step": 162, "loss": 1.338950276374817, "percent_done": 32.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13995599746704, "wps": 5506.948587611595, "avg_wps": 3986.177203137962, "eta_in_seconds": 5556.995304313707, "at": "2024-05-26T00:35:31.072109"} +{"lr": 4.834803817658786e-05, "step": 163, "loss": 1.2776546478271484, "percent_done": 32.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1387357711792, "wps": 5542.646794583385, "avg_wps": 3993.056456146613, "eta_in_seconds": 5531.009201235566, "at": "2024-05-26T00:35:42.897260"} +{"lr": 4.819065808920307e-05, "step": 164, "loss": 1.4070043563842773, "percent_done": 32.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5540.459467868356, "avg_wps": 3999.8682185431176, "eta_in_seconds": 5505.205370996056, "at": "2024-05-26T00:35:54.726921"} +{"lr": 4.803248228875308e-05, "step": 165, "loss": 1.471192717552185, "percent_done": 33.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.141496658325195, "wps": 5542.936944196005, "avg_wps": 4006.6281208824953, "eta_in_seconds": 5479.5602031476565, "at": "2024-05-26T00:36:06.551378"} +{"lr": 4.7873517694359834e-05, "step": 166, "loss": 1.555643081665039, "percent_done": 33.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139355182647705, "wps": 5540.876489640953, "avg_wps": 4013.322544294357, "eta_in_seconds": 5454.090409732727, "at": "2024-05-26T00:36:18.380298"} +{"lr": 4.7713771259649654e-05, "step": 167, "loss": 1.4674922227859497, "percent_done": 33.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137837886810303, "wps": 5530.920318385281, "avg_wps": 4019.927364713092, "eta_in_seconds": 5428.826448847434, "at": "2024-05-26T00:36:30.230598"} +{"lr": 4.755324997244911e-05, "step": 168, "loss": 1.5082496404647827, "percent_done": 33.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.140522956848145, "wps": 5549.663373325819, "avg_wps": 4026.53387208514, "eta_in_seconds": 5403.643106256212, "at": "2024-05-26T00:36:42.040702"} +{"lr": 4.739196085447931e-05, "step": 169, "loss": 1.4904391765594482, "percent_done": 33.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1380033493042, "wps": 5523.3548572738, "avg_wps": 4033.000956615353, "eta_in_seconds": 5378.728205957356, "at": "2024-05-26T00:36:53.907068"} +{"lr": 4.722991096104879e-05, "step": 170, "loss": 1.4823875427246094, "percent_done": 34.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5537.428733245111, "avg_wps": 4039.4565655614915, "eta_in_seconds": 5353.908291620367, "at": "2024-05-26T00:37:05.743274"} +{"lr": 4.706710738074485e-05, "step": 171, "loss": 1.6395151615142822, "percent_done": 34.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13873529434204, "wps": 5531.952166362009, "avg_wps": 4045.839894515075, "eta_in_seconds": 5329.262788977539, "at": "2024-05-26T00:37:17.591244"} +{"lr": 4.6903557235123503e-05, "step": 172, "loss": 1.6742452383041382, "percent_done": 34.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13702630996704, "wps": 5530.9124168279295, "avg_wps": 4052.1656095073636, "eta_in_seconds": 5304.770355280055, "at": "2024-05-26T00:37:29.441588"} +{"lr": 4.673926767839795e-05, "step": 173, "loss": 1.2659401893615723, "percent_done": 34.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1384916305542, "wps": 5533.1006750381885, "avg_wps": 4058.444471670209, "eta_in_seconds": 5280.41523041477, "at": "2024-05-26T00:37:41.287088"} +{"lr": 4.6574245897125624e-05, "step": 174, "loss": 1.0927540063858032, "percent_done": 34.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13739776611328, "wps": 5530.781432328368, "avg_wps": 4064.6631204199402, "eta_in_seconds": 5256.213213013507, "at": "2024-05-26T00:37:53.137554"} +{"lr": 4.640849910989384e-05, "step": 175, "loss": 1.337214469909668, "percent_done": 35.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5552.215929196103, "avg_wps": 4070.8955582678295, "eta_in_seconds": 5232.067414930888, "at": "2024-05-26T00:38:04.942264"} +{"lr": 4.6242034567004e-05, "step": 176, "loss": 1.5160088539123535, "percent_done": 35.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137300491333008, "wps": 5531.864772729148, "avg_wps": 4077.013410479484, "eta_in_seconds": 5208.141809252175, "at": "2024-05-26T00:38:16.813569"} +{"lr": 4.60748595501545e-05, "step": 177, "loss": 1.3292492628097534, "percent_done": 35.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1370267868042, "wps": 5534.255231897187, "avg_wps": 4083.0875934900823, "eta_in_seconds": 5184.343346870552, "at": "2024-05-26T00:38:28.656672"} +{"lr": 4.590698137212215e-05, "step": 178, "loss": 1.4860689640045166, "percent_done": 35.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5538.810981517906, "avg_wps": 4089.125310203, "eta_in_seconds": 5160.661608326301, "at": "2024-05-26T00:38:40.489929"} +{"lr": 4.5738407376442294e-05, "step": 179, "loss": 1.2346954345703125, "percent_done": 35.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13824987411499, "wps": 5536.797087632224, "avg_wps": 4095.106997732116, "eta_in_seconds": 5137.119985302067, "at": "2024-05-26T00:38:52.327495"} +{"lr": 4.5569144937087604e-05, "step": 180, "loss": 1.4844282865524292, "percent_done": 36.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5536.149641524129, "avg_wps": 4101.037483197592, "eta_in_seconds": 5113.7108807033965, "at": "2024-05-26T00:39:04.166490"} +{"lr": 4.5399201458145525e-05, "step": 181, "loss": 1.6267871856689453, "percent_done": 36.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1382474899292, "wps": 5543.4886028289675, "avg_wps": 4106.94164027059, "eta_in_seconds": 5090.402014727092, "at": "2024-05-26T00:39:15.989880"} +{"lr": 4.522858437349436e-05, "step": 182, "loss": 1.6486303806304932, "percent_done": 36.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5544.838421617288, "avg_wps": 4112.801742647404, "eta_in_seconds": 5067.214347800056, "at": "2024-05-26T00:39:27.810368"} +{"lr": 4.505730114647811e-05, "step": 183, "loss": 1.3425076007843018, "percent_done": 36.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1370267868042, "wps": 5541.176395465127, "avg_wps": 4118.603225659315, "eta_in_seconds": 5044.164456185096, "at": "2024-05-26T00:39:39.638662"} +{"lr": 4.488535926958002e-05, "step": 184, "loss": 1.781583547592163, "percent_done": 36.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13717746734619, "wps": 5543.097344249737, "avg_wps": 4124.363554443577, "eta_in_seconds": 5021.229512536007, "at": "2024-05-26T00:39:51.462856"} +{"lr": 4.471276626409479e-05, "step": 185, "loss": 1.369985818862915, "percent_done": 37.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5539.250414978418, "avg_wps": 4130.06593202918, "eta_in_seconds": 4998.428678802542, "at": "2024-05-26T00:40:03.295248"} +{"lr": 4.45395296797996e-05, "step": 186, "loss": 1.2858965396881104, "percent_done": 37.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13800287246704, "wps": 5531.820130677768, "avg_wps": 4135.700231455384, "eta_in_seconds": 4975.772625753956, "at": "2024-05-26T00:40:15.143534"} +{"lr": 4.4365657094623857e-05, "step": 187, "loss": 1.61137056350708, "percent_done": 37.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13840961456299, "wps": 5524.408643184817, "avg_wps": 4141.267176238552, "eta_in_seconds": 4953.258779751426, "at": "2024-05-26T00:40:27.007606"} +{"lr": 4.419115611431772e-05, "step": 188, "loss": 1.7724450826644897, "percent_done": 37.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1387357711792, "wps": 5533.056458539925, "avg_wps": 4146.815544191923, "eta_in_seconds": 4930.827470404037, "at": "2024-05-26T00:40:38.853134"} +{"lr": 4.401603437211934e-05, "step": 189, "loss": 1.2718950510025024, "percent_done": 37.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5538.770579909343, "avg_wps": 4152.3368601983875, "eta_in_seconds": 4908.488084231735, "at": "2024-05-26T00:40:50.686456"} +{"lr": 4.384029952842108e-05, "step": 190, "loss": 1.0087783336639404, "percent_done": 38.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1397123336792, "wps": 5545.144349630792, "avg_wps": 4157.833429691444, "eta_in_seconds": 4886.237109673651, "at": "2024-05-26T00:41:02.506141"} +{"lr": 4.366395927043427e-05, "step": 191, "loss": 1.608473300933838, "percent_done": 38.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5542.126032107357, "avg_wps": 4163.277873645289, "eta_in_seconds": 4864.105787459468, "at": "2024-05-26T00:41:14.332385"} +{"lr": 4.348702131185308e-05, "step": 192, "loss": 1.3803850412368774, "percent_done": 38.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5544.102431138085, "avg_wps": 4168.685481094917, "eta_in_seconds": 4842.075059761603, "at": "2024-05-26T00:41:26.154264"} +{"lr": 4.3309493392517e-05, "step": 193, "loss": 1.5278865098953247, "percent_done": 38.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139034271240234, "wps": 5548.627596303829, "avg_wps": 4174.064178408998, "eta_in_seconds": 4820.13479909378, "at": "2024-05-26T00:41:37.966544"} +{"lr": 4.313138327807234e-05, "step": 194, "loss": 1.8288185596466064, "percent_done": 38.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13921880722046, "wps": 5536.45461148206, "avg_wps": 4179.3654305104155, "eta_in_seconds": 4798.3399234727485, "at": "2024-05-26T00:41:49.804810"} +{"lr": 4.2952698759632504e-05, "step": 195, "loss": 1.122506022453308, "percent_done": 39.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13830041885376, "wps": 5535.220108612204, "avg_wps": 4184.621969232516, "eta_in_seconds": 4776.651307326097, "at": "2024-05-26T00:42:01.645708"} +{"lr": 4.277344765343719e-05, "step": 196, "loss": 1.3557201623916626, "percent_done": 39.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1389799118042, "wps": 5528.652719222615, "avg_wps": 4189.81868605775, "eta_in_seconds": 4755.085003152186, "at": "2024-05-26T00:42:13.500731"} +{"lr": 4.2593637800510475e-05, "step": 197, "loss": 1.6514897346496582, "percent_done": 39.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139344215393066, "wps": 5537.284723655701, "avg_wps": 4195.000559111975, "eta_in_seconds": 4733.588880427598, "at": "2024-05-26T00:42:25.337177"} +{"lr": 4.241327706631782e-05, "step": 198, "loss": 1.0746054649353027, "percent_done": 39.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5543.368983630239, "avg_wps": 4200.160390036222, "eta_in_seconds": 4712.170527332961, "at": "2024-05-26T00:42:37.160614"} +{"lr": 4.223237334042203e-05, "step": 199, "loss": 1.47548508644104, "percent_done": 39.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13890552520752, "wps": 5529.567922854537, "avg_wps": 4205.240869946182, "eta_in_seconds": 4690.893247276095, "at": "2024-05-26T00:42:49.013627"} +{"lr": 4.205093453613813e-05, "step": 200, "loss": 1.526173710823059, "percent_done": 40.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139493942260742, "wps": 5540.243052281161, "avg_wps": 4210.313551529432, "eta_in_seconds": 4669.67596578598, "at": "2024-05-26T00:43:00.843868"} +{"lr": 4.186896859018719e-05, "step": 201, "loss": 1.4787572622299194, "percent_done": 40.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139551639556885, "wps": 5596.201714965491, "avg_wps": 4215.507392203633, "eta_in_seconds": 4648.376144765029, "at": "2024-05-26T00:43:27.376702"} +{"lr": 4.1686483462349175e-05, "step": 202, "loss": 1.4978930950164795, "percent_done": 40.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5560.3849281835455, "avg_wps": 4220.560943614809, "eta_in_seconds": 4627.282548673083, "at": "2024-05-26T00:43:39.163958"} +{"lr": 4.1503487135114756e-05, "step": 203, "loss": 1.2025593519210815, "percent_done": 40.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14137363433838, "wps": 5556.142213502009, "avg_wps": 4225.5645791954, "eta_in_seconds": 4606.293818305866, "at": "2024-05-26T00:43:50.960251"} +{"lr": 4.1319987613336105e-05, "step": 204, "loss": 1.8979005813598633, "percent_done": 40.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5541.944682228907, "avg_wps": 4230.490412043713, "eta_in_seconds": 4585.4390651198, "at": "2024-05-26T00:44:02.786871"} +{"lr": 4.113599292387675e-05, "step": 205, "loss": 1.567550778388977, "percent_done": 41.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1387357711792, "wps": 5529.45902565837, "avg_wps": 4235.343865045288, "eta_in_seconds": 4564.710827746043, "at": "2024-05-26T00:44:14.640109"} +{"lr": 4.095151111526049e-05, "step": 206, "loss": 1.1945691108703613, "percent_done": 41.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5541.909598040349, "avg_wps": 4240.196645060535, "eta_in_seconds": 4544.030763866832, "at": "2024-05-26T00:44:26.466748"} +{"lr": 4.076655025731926e-05, "step": 207, "loss": 1.416570782661438, "percent_done": 41.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5526.984356291331, "avg_wps": 4244.971091888022, "eta_in_seconds": 4523.4814523694595, "at": "2024-05-26T00:44:38.325229"} +{"lr": 4.058111844084018e-05, "step": 208, "loss": 1.490580677986145, "percent_done": 41.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5535.710811362995, "avg_wps": 4249.7350046017655, "eta_in_seconds": 4502.989475644552, "at": "2024-05-26T00:44:50.165132"} +{"lr": 4.0395223777211613e-05, "step": 209, "loss": 1.667999029159546, "percent_done": 41.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.141624927520752, "wps": 5531.944261856157, "avg_wps": 4254.453228868484, "eta_in_seconds": 4482.591528000444, "at": "2024-05-26T00:45:02.012975"} +{"lr": 4.020887439806836e-05, "step": 210, "loss": 1.9307905435562134, "percent_done": 42.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5537.607779624579, "avg_wps": 4259.152826815559, "eta_in_seconds": 4462.258287690935, "at": "2024-05-26T00:45:13.848847"} +{"lr": 4.0022078454935966e-05, "step": 211, "loss": 1.26886785030365, "percent_done": 42.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5522.882654546504, "avg_wps": 4263.776641407079, "eta_in_seconds": 4442.048820303515, "at": "2024-05-26T00:45:25.716202"} +{"lr": 3.9834844118874095e-05, "step": 212, "loss": 1.5193549394607544, "percent_done": 42.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.141427040100098, "wps": 5533.928890404986, "avg_wps": 4268.397803839718, "eta_in_seconds": 4421.885884914758, "at": "2024-05-26T00:45:37.559889"} +{"lr": 3.964717958011919e-05, "step": 213, "loss": 1.251197338104248, "percent_done": 42.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1380033493042, "wps": 5534.057684293295, "avg_wps": 4272.985822552458, "eta_in_seconds": 4401.800703556884, "at": "2024-05-26T00:45:49.403218"} +{"lr": 3.9459093047726116e-05, "step": 214, "loss": 1.432743787765503, "percent_done": 42.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1382474899292, "wps": 5540.013813136418, "avg_wps": 4277.557308878169, "eta_in_seconds": 4381.775543041318, "at": "2024-05-26T00:46:01.233842"} +{"lr": 3.92705927492091e-05, "step": 215, "loss": 1.4782277345657349, "percent_done": 43.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1370267868042, "wps": 5536.510368306427, "avg_wps": 4282.086184191149, "eta_in_seconds": 4361.836543354877, "at": "2024-05-26T00:46:13.072043"} +{"lr": 3.908168693018187e-05, "step": 216, "loss": 1.644234299659729, "percent_done": 43.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817262649536, "wps": 5532.466453108508, "avg_wps": 4286.571361637611, "eta_in_seconds": 4341.983937691759, "at": "2024-05-26T00:46:24.918860"} +{"lr": 3.889238385399692e-05, "step": 217, "loss": 1.4462400674819946, "percent_done": 43.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13890552520752, "wps": 5528.062318436874, "avg_wps": 4291.012258137125, "eta_in_seconds": 4322.217435951057, "at": "2024-05-26T00:46:36.775121"} +{"lr": 3.870269180138406e-05, "step": 218, "loss": 1.675262689590454, "percent_done": 43.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1380033493042, "wps": 5534.44844776445, "avg_wps": 4295.43916347693, "eta_in_seconds": 4302.505819926569, "at": "2024-05-26T00:46:48.617609"} +{"lr": 3.851261907008817e-05, "step": 219, "loss": 1.3199164867401123, "percent_done": 43.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5535.384075250543, "avg_wps": 4299.837237477709, "eta_in_seconds": 4282.863509224974, "at": "2024-05-26T00:47:00.458258"} +{"lr": 3.8322173974506286e-05, "step": 220, "loss": 1.6845101118087769, "percent_done": 44.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13995599746704, "wps": 5510.513466249422, "avg_wps": 4304.135562061595, "eta_in_seconds": 4263.36014175415, "at": "2024-05-26T00:47:12.352268"} +{"lr": 3.813136484532385e-05, "step": 221, "loss": 1.387367606163025, "percent_done": 44.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1399564743042, "wps": 5527.326662083986, "avg_wps": 4308.449838288029, "eta_in_seconds": 4243.879976856223, "at": "2024-05-26T00:47:24.210069"} +{"lr": 3.794020002915029e-05, "step": 222, "loss": 1.4622544050216675, "percent_done": 44.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5520.525512400772, "avg_wps": 4312.715114006132, "eta_in_seconds": 4224.486783472267, "at": "2024-05-26T00:47:36.082497"} +{"lr": 3.774868788815397e-05, "step": 223, "loss": 1.635811448097229, "percent_done": 44.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792848587036, "wps": 5533.602810192979, "avg_wps": 4316.9862513436165, "eta_in_seconds": 4205.126202185593, "at": "2024-05-26T00:47:47.926910"} +{"lr": 3.755683679969634e-05, "step": 224, "loss": 1.5653899908065796, "percent_done": 44.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5528.7669224035835, "avg_wps": 4321.214432036123, "eta_in_seconds": 4185.84550350053, "at": "2024-05-26T00:47:59.781640"} +{"lr": 3.736465515596552e-05, "step": 225, "loss": 1.6065657138824463, "percent_done": 45.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1392240524292, "wps": 5529.020254575828, "avg_wps": 4325.413898247056, "eta_in_seconds": 4166.63015932507, "at": "2024-05-26T00:48:11.635839"} +{"lr": 3.717215136360919e-05, "step": 226, "loss": 1.5461000204086304, "percent_done": 45.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5533.510797242492, "avg_wps": 4329.596437122061, "eta_in_seconds": 4147.468305830407, "at": "2024-05-26T00:48:23.480410"} +{"lr": 3.697933384336687e-05, "step": 227, "loss": 1.3097504377365112, "percent_done": 45.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13995599746704, "wps": 5512.12259994092, "avg_wps": 4333.692098894464, "eta_in_seconds": 4128.426199121097, "at": "2024-05-26T00:48:35.370927"} +{"lr": 3.6786211029701516e-05, "step": 228, "loss": 1.6260541677474976, "percent_done": 45.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13849115371704, "wps": 2808.324622321751, "avg_wps": 4323.392578538777, "eta_in_seconds": 4123.102789343449, "at": "2024-05-26T00:48:58.708265"} +{"lr": 3.659279137043063e-05, "step": 229, "loss": 1.5031825304031372, "percent_done": 45.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5571.398671168329, "avg_wps": 4327.625758035511, "eta_in_seconds": 4103.926030808661, "at": "2024-05-26T00:49:10.472346"} +{"lr": 3.639908332635672e-05, "step": 230, "loss": 1.608676791191101, "percent_done": 46.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1387357711792, "wps": 5544.593703509994, "avg_wps": 4331.759524281279, "eta_in_seconds": 4084.880497362303, "at": "2024-05-26T00:49:22.293236"} +{"lr": 3.6205095370897137e-05, "step": 231, "loss": 1.805351734161377, "percent_done": 46.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14140796661377, "wps": 5539.069699711945, "avg_wps": 4335.8506645206, "eta_in_seconds": 4065.9112511083677, "at": "2024-05-26T00:49:34.125896"} +{"lr": 3.601083598971351e-05, "step": 232, "loss": 1.4192653894424438, "percent_done": 46.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5532.713999521479, "avg_wps": 4339.89733473655, "eta_in_seconds": 4047.019236934596, "at": "2024-05-26T00:49:45.972161"} +{"lr": 3.581631368034047e-05, "step": 233, "loss": 1.5427579879760742, "percent_done": 46.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5538.066436591779, "avg_wps": 4343.930880044961, "eta_in_seconds": 4028.1745919076156, "at": "2024-05-26T00:49:57.806991"} +{"lr": 3.5621536951813995e-05, "step": 234, "loss": 1.4073643684387207, "percent_done": 46.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5539.973840595753, "avg_wps": 4347.94238181473, "eta_in_seconds": 4009.3852376958243, "at": "2024-05-26T00:50:09.637759"} +{"lr": 3.542651432429918e-05, "step": 235, "loss": 1.5565159320831299, "percent_done": 47.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.138086318969727, "wps": 5532.181295517999, "avg_wps": 4351.906573304648, "eta_in_seconds": 3990.673905210292, "at": "2024-05-26T00:50:21.485170"} +{"lr": 3.523125432871754e-05, "step": 236, "loss": 1.3352882862091064, "percent_done": 47.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5530.5869145454035, "avg_wps": 4355.840123953177, "eta_in_seconds": 3972.0245710712366, "at": "2024-05-26T00:50:33.335979"} +{"lr": 3.503576550637384e-05, "step": 237, "loss": 1.6341153383255005, "percent_done": 47.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13873529434204, "wps": 5522.12885120343, "avg_wps": 4359.725296590551, "eta_in_seconds": 3953.452758475195, "at": "2024-05-26T00:50:45.204959"} +{"lr": 3.484005640858246e-05, "step": 238, "loss": 1.425567865371704, "percent_done": 47.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14134693145752, "wps": 5536.1170836452475, "avg_wps": 4363.621277418509, "eta_in_seconds": 3934.904270646953, "at": "2024-05-26T00:50:57.043930"} +{"lr": 3.464413559629336e-05, "step": 239, "loss": 1.2422451972961426, "percent_done": 47.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13768482208252, "wps": 5527.562522108759, "avg_wps": 4367.469226769415, "eta_in_seconds": 3916.43194533791, "at": "2024-05-26T00:51:08.901282"} +{"lr": 3.444801163971754e-05, "step": 240, "loss": 1.5461735725402832, "percent_done": 48.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1406888961792, "wps": 5531.341025446556, "avg_wps": 4371.301656899959, "eta_in_seconds": 3898.0059802333512, "at": "2024-05-26T00:51:20.750660"} +{"lr": 3.4251693117952235e-05, "step": 241, "loss": 1.6313444375991821, "percent_done": 48.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5528.268444044248, "avg_wps": 4375.10095004529, "eta_in_seconds": 3879.6416799992444, "at": "2024-05-26T00:51:32.606526"} +{"lr": 3.4055188618605555e-05, "step": 242, "loss": 1.125512719154358, "percent_done": 48.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5537.499569525027, "avg_wps": 4378.899264957602, "eta_in_seconds": 3861.3101094399603, "at": "2024-05-26T00:51:44.442624"} +{"lr": 3.3858506737420905e-05, "step": 243, "loss": 1.6871873140335083, "percent_done": 48.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1399564743042, "wps": 5516.1301769274905, "avg_wps": 4382.617539458016, "eta_in_seconds": 3843.080498893565, "at": "2024-05-26T00:51:56.324569"} +{"lr": 3.366165607790091e-05, "step": 244, "loss": 1.508838415145874, "percent_done": 48.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5536.8670155193395, "avg_wps": 4386.365116295409, "eta_in_seconds": 3824.856243196081, "at": "2024-05-26T00:52:08.161952"} +{"lr": 3.3464645250931154e-05, "step": 245, "loss": 1.526856541633606, "percent_done": 49.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13995599746704, "wps": 5511.6593887264935, "avg_wps": 4390.023459904286, "eta_in_seconds": 3806.740477046188, "at": "2024-05-26T00:52:20.053560"} +{"lr": 3.3267482874403404e-05, "step": 246, "loss": 1.343733310699463, "percent_done": 49.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14134693145752, "wps": 5528.1191293001275, "avg_wps": 4393.70048605466, "eta_in_seconds": 3788.6387688086284, "at": "2024-05-26T00:52:31.909674"} +{"lr": 3.3070177572838744e-05, "step": 247, "loss": 1.6397329568862915, "percent_done": 49.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139309406280518, "wps": 5531.113857944268, "avg_wps": 4397.361496325575, "eta_in_seconds": 3770.5810663632533, "at": "2024-05-26T00:52:43.759385"} +{"lr": 3.287273797701024e-05, "step": 248, "loss": 1.7264926433563232, "percent_done": 49.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13873529434204, "wps": 5524.28418381858, "avg_wps": 4400.9815580735885, "eta_in_seconds": 3752.588321962664, "at": "2024-05-26T00:52:55.623726"} +{"lr": 3.267517272356543e-05, "step": 249, "loss": 1.706379771232605, "percent_done": 49.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.141398906707764, "wps": 5536.513713751602, "avg_wps": 4404.609590248677, "eta_in_seconds": 3734.6183953323516, "at": "2024-05-26T00:53:07.461861"} +{"lr": 3.247749045464852e-05, "step": 250, "loss": 1.6563538312911987, "percent_done": 50.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139185905456543, "wps": 5534.978802166535, "avg_wps": 4408.210619804437, "eta_in_seconds": 3716.7008142471313, "at": "2024-05-26T00:53:19.303283"} +{"lr": 3.227969981752235e-05, "step": 251, "loss": 1.1807035207748413, "percent_done": 50.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137569427490234, "wps": 5526.1845485071035, "avg_wps": 4411.766483353033, "eta_in_seconds": 3698.850349757776, "at": "2024-05-26T00:53:31.163558"} +{"lr": 3.208180946419016e-05, "step": 252, "loss": 1.2953325510025024, "percent_done": 50.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13995599746704, "wps": 5509.568005409552, "avg_wps": 4415.257579297445, "eta_in_seconds": 3681.082634047856, "at": "2024-05-26T00:53:43.059603"} +{"lr": 3.188382805101706e-05, "step": 253, "loss": 1.3787448406219482, "percent_done": 50.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5531.01647435701, "avg_wps": 4418.7808608415135, "eta_in_seconds": 3663.3163104896016, "at": "2024-05-26T00:53:54.909438"} +{"lr": 3.168576423835144e-05, "step": 254, "loss": 1.3832790851593018, "percent_done": 50.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13890552520752, "wps": 5528.566319366759, "avg_wps": 4422.275791900193, "eta_in_seconds": 3645.6016672521123, "at": "2024-05-26T00:54:06.764651"} +{"lr": 3.148762669014611e-05, "step": 255, "loss": 1.6247435808181763, "percent_done": 51.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5534.374123801316, "avg_wps": 4425.763359897295, "eta_in_seconds": 3627.9210374168324, "at": "2024-05-26T00:54:18.607391"} +{"lr": 3.12894240735793e-05, "step": 256, "loss": 1.197739839553833, "percent_done": 51.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5532.6957362312305, "avg_wps": 4429.2249215600295, "eta_in_seconds": 3610.289448648691, "at": "2024-05-26T00:54:30.453702"} +{"lr": 3.109116505867555e-05, "step": 257, "loss": 1.3123215436935425, "percent_done": 51.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5547.986786697155, "avg_wps": 4432.702986970204, "eta_in_seconds": 3592.67202129531, "at": "2024-05-26T00:54:42.267378"} +{"lr": 3.089285831792642e-05, "step": 258, "loss": 1.6977781057357788, "percent_done": 51.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5528.743125051717, "avg_wps": 4436.111640089365, "eta_in_seconds": 3575.1381585339245, "at": "2024-05-26T00:54:54.122156"} +{"lr": 3.0694512525911205e-05, "step": 259, "loss": 1.0950196981430054, "percent_done": 51.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1380033493042, "wps": 5534.838597738931, "avg_wps": 4439.514315447596, "eta_in_seconds": 3557.6360110030673, "at": "2024-05-26T00:55:05.963894"} +{"lr": 3.0496136358917387e-05, "step": 260, "loss": 1.3071869611740112, "percent_done": 52.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5535.010900840757, "avg_wps": 4442.896407211733, "eta_in_seconds": 3540.17707333198, "at": "2024-05-26T00:55:17.805265"} +{"lr": 3.029773849456115e-05, "step": 261, "loss": 1.543917179107666, "percent_done": 52.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963747024536, "wps": 5523.823033593049, "avg_wps": 4446.229964108923, "eta_in_seconds": 3522.7831503175685, "at": "2024-05-26T00:55:29.670622"} +{"lr": 3.009932761140782e-05, "step": 262, "loss": 1.5751579999923706, "percent_done": 52.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5544.538007433828, "avg_wps": 4449.594133901399, "eta_in_seconds": 3505.391172907735, "at": "2024-05-26T00:55:41.491625"} +{"lr": 2.9900912388592177e-05, "step": 263, "loss": 1.1802653074264526, "percent_done": 52.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5536.393280272336, "avg_wps": 4452.917753268135, "eta_in_seconds": 3488.0572381110246, "at": "2024-05-26T00:55:53.329982"} +{"lr": 2.9702501505438846e-05, "step": 264, "loss": 1.4496034383773804, "percent_done": 52.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1405029296875, "wps": 5538.008863218723, "avg_wps": 4456.225069707394, "eta_in_seconds": 3470.761857415691, "at": "2024-05-26T00:56:05.165005"} +{"lr": 2.9504103641082615e-05, "step": 265, "loss": 1.2859277725219727, "percent_done": 53.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137210845947266, "wps": 5541.263971855777, "avg_wps": 4459.52024661947, "eta_in_seconds": 3453.5015311735983, "at": "2024-05-26T00:56:16.993024"} +{"lr": 2.93057274740888e-05, "step": 266, "loss": 1.5144016742706299, "percent_done": 53.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139424800872803, "wps": 5527.408799553815, "avg_wps": 4462.761600111927, "eta_in_seconds": 3436.3081370099144, "at": "2024-05-26T00:56:28.850617"} +{"lr": 2.9107381682073582e-05, "step": 267, "loss": 1.6225457191467285, "percent_done": 53.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5540.866995945731, "avg_wps": 4466.016161916648, "eta_in_seconds": 3419.1295880682014, "at": "2024-05-26T00:56:40.679565"} +{"lr": 2.8909074941324465e-05, "step": 268, "loss": 1.184424877166748, "percent_done": 53.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1387357711792, "wps": 5531.724726015742, "avg_wps": 4469.228902802474, "eta_in_seconds": 3402.0078923381975, "at": "2024-05-26T00:56:52.527961"} +{"lr": 2.8710815926420708e-05, "step": 269, "loss": 1.7449427843093872, "percent_done": 53.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5538.856629348349, "avg_wps": 4472.4396398281415, "eta_in_seconds": 3384.912311657654, "at": "2024-05-26T00:57:04.361113"} +{"lr": 2.851261330985389e-05, "step": 270, "loss": 1.6234735250473022, "percent_done": 54.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137887477874756, "wps": 5533.3855932514725, "avg_wps": 4475.617915511204, "eta_in_seconds": 3367.8656857102005, "at": "2024-05-26T00:57:16.205956"} +{"lr": 2.8314475761648556e-05, "step": 271, "loss": 1.1902457475662231, "percent_done": 54.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1397123336792, "wps": 5539.079410485766, "avg_wps": 4478.790956485106, "eta_in_seconds": 3350.8471696517563, "at": "2024-05-26T00:57:28.038572"} +{"lr": 2.811641194898294e-05, "step": 272, "loss": 1.4205036163330078, "percent_done": 54.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5536.018966326275, "avg_wps": 4481.937748267793, "eta_in_seconds": 3333.872275618946, "at": "2024-05-26T00:57:39.877881"} +{"lr": 2.7918430535809843e-05, "step": 273, "loss": 1.005091667175293, "percent_done": 54.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5538.130482796971, "avg_wps": 4485.070937758747, "eta_in_seconds": 3316.931260720278, "at": "2024-05-26T00:57:51.712595"} +{"lr": 2.772054018247765e-05, "step": 274, "loss": 1.2020037174224854, "percent_done": 54.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137707233428955, "wps": 5529.24002068975, "avg_wps": 4488.164248618584, "eta_in_seconds": 3300.043220245055, "at": "2024-05-26T00:58:03.590415"} +{"lr": 2.7522749545351488e-05, "step": 275, "loss": 1.2330303192138672, "percent_done": 55.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1370267868042, "wps": 5533.795869101056, "avg_wps": 4491.250207461964, "eta_in_seconds": 3283.183817169883, "at": "2024-05-26T00:58:15.434462"} +{"lr": 2.7325067276434586e-05, "step": 276, "loss": 1.5320179462432861, "percent_done": 55.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.140522956848145, "wps": 5539.285912012344, "avg_wps": 4494.331112267575, "eta_in_seconds": 3266.351239660512, "at": "2024-05-26T00:58:27.266703"} +{"lr": 2.7127502022989765e-05, "step": 277, "loss": 1.179079294204712, "percent_done": 55.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13890552520752, "wps": 5522.972760795532, "avg_wps": 4497.355020491515, "eta_in_seconds": 3249.5829067109726, "at": "2024-05-26T00:58:39.133893"} +{"lr": 2.693006242716126e-05, "step": 278, "loss": 1.4817994832992554, "percent_done": 55.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5538.101025821754, "avg_wps": 4500.39723569289, "eta_in_seconds": 3232.8239570967585, "at": "2024-05-26T00:58:50.968629"} +{"lr": 2.6732757125596597e-05, "step": 279, "loss": 1.6966520547866821, "percent_done": 55.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5532.905548609737, "avg_wps": 4503.409392151352, "eta_in_seconds": 3216.109116182532, "at": "2024-05-26T00:59:02.814541"} +{"lr": 2.653559474906885e-05, "step": 280, "loss": 1.6227508783340454, "percent_done": 56.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137199878692627, "wps": 5514.956945650416, "avg_wps": 4506.361363657148, "eta_in_seconds": 3199.45935012613, "at": "2024-05-26T00:59:14.698974"} +{"lr": 2.6338583922099093e-05, "step": 281, "loss": 1.2926881313323975, "percent_done": 56.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5534.2261504001835, "avg_wps": 4509.341841689588, "eta_in_seconds": 3182.811262457396, "at": "2024-05-26T00:59:26.542022"} +{"lr": 2.6141733262579107e-05, "step": 282, "loss": 1.2204015254974365, "percent_done": 56.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14134693145752, "wps": 5538.880290622555, "avg_wps": 4512.316047333792, "eta_in_seconds": 3166.1895687563197, "at": "2024-05-26T00:59:38.375148"} +{"lr": 2.5945051381394456e-05, "step": 283, "loss": 1.5107355117797852, "percent_done": 56.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5552.843918788635, "avg_wps": 4515.305825641744, "eta_in_seconds": 3149.5789098579558, "at": "2024-05-26T00:59:50.178525"} +{"lr": 2.574854688204777e-05, "step": 284, "loss": 1.6739741563796997, "percent_done": 56.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817262649536, "wps": 5526.0876717026995, "avg_wps": 4518.215794168703, "eta_in_seconds": 3133.045574819538, "at": "2024-05-26T01:00:02.039040"} +{"lr": 2.555222836028246e-05, "step": 285, "loss": 1.445129156112671, "percent_done": 57.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5512.8998776916305, "avg_wps": 4521.078008843842, "eta_in_seconds": 3116.566441109306, "at": "2024-05-26T01:00:13.927902"} +{"lr": 2.5356104403706647e-05, "step": 286, "loss": 1.277710199356079, "percent_done": 57.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5534.471402795223, "avg_wps": 4523.974392085318, "eta_in_seconds": 3100.084745071985, "at": "2024-05-26T01:00:25.770419"} +{"lr": 2.5160183591417547e-05, "step": 287, "loss": 1.2438263893127441, "percent_done": 57.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137596607208252, "wps": 5525.886374342613, "avg_wps": 4526.834222718159, "eta_in_seconds": 3083.6490388680836, "at": "2024-05-26T01:00:37.631344"} +{"lr": 2.4964474493626167e-05, "step": 288, "loss": 1.4689997434616089, "percent_done": 57.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5535.8439247466695, "avg_wps": 4529.700964323227, "eta_in_seconds": 3067.2294064064818, "at": "2024-05-26T01:00:49.470961"} +{"lr": 2.4768985671282466e-05, "step": 289, "loss": 1.5166946649551392, "percent_done": 57.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5529.101775088918, "avg_wps": 4532.535804074292, "eta_in_seconds": 3050.85201700336, "at": "2024-05-26T01:01:01.324956"} +{"lr": 2.457372567570083e-05, "step": 290, "loss": 1.2938913106918335, "percent_done": 58.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13890552520752, "wps": 5528.222525844154, "avg_wps": 4535.3525667349295, "eta_in_seconds": 3034.507195965997, "at": "2024-05-26T01:01:13.180849"} +{"lr": 2.4378703048186006e-05, "step": 291, "loss": 1.318616271018982, "percent_done": 58.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13748550415039, "wps": 5535.9577562605255, "avg_wps": 4538.171325319706, "eta_in_seconds": 3018.1813373991713, "at": "2024-05-26T01:01:25.020198"} +{"lr": 2.4183926319659536e-05, "step": 292, "loss": 1.2825901508331299, "percent_done": 58.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.138924598693848, "wps": 5525.258913939859, "avg_wps": 4540.949546913198, "eta_in_seconds": 3001.90254464868, "at": "2024-05-26T01:01:36.882483"} +{"lr": 2.3989404010286496e-05, "step": 293, "loss": 1.2012560367584229, "percent_done": 58.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1387357711792, "wps": 5516.096857843715, "avg_wps": 4543.690991752467, "eta_in_seconds": 2985.6678248200396, "at": "2024-05-26T01:01:48.764522"} +{"lr": 2.379514462910286e-05, "step": 294, "loss": 1.5051480531692505, "percent_done": 58.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5539.113231032796, "avg_wps": 4546.470027275156, "eta_in_seconds": 2969.42813193717, "at": "2024-05-26T01:02:00.597240"} +{"lr": 2.3601156673643287e-05, "step": 295, "loss": 1.293953537940979, "percent_done": 59.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1384916305542, "wps": 5534.530128425111, "avg_wps": 4549.223100903126, "eta_in_seconds": 2953.2251336130043, "at": "2024-05-26T01:02:12.439712"} +{"lr": 2.340744862956937e-05, "step": 296, "loss": 1.432934284210205, "percent_done": 59.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5527.644221957036, "avg_wps": 4551.945119217193, "eta_in_seconds": 2937.061772462484, "at": "2024-05-26T01:02:24.296933"} +{"lr": 2.3214028970298496e-05, "step": 297, "loss": 1.1521751880645752, "percent_done": 59.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5548.077378022608, "avg_wps": 4554.698572337183, "eta_in_seconds": 2920.8975717515655, "at": "2024-05-26T01:02:36.110557"} +{"lr": 2.3020906156633134e-05, "step": 298, "loss": 1.6014556884765625, "percent_done": 59.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137086868286133, "wps": 5535.5268712425395, "avg_wps": 4557.408362770301, "eta_in_seconds": 2904.7807319932335, "at": "2024-05-26T01:02:47.950911"} +{"lr": 2.2828088636390805e-05, "step": 299, "loss": 1.257323980331421, "percent_done": 59.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13995599746704, "wps": 5506.703782656311, "avg_wps": 4560.037461480972, "eta_in_seconds": 2888.7341631009026, "at": "2024-05-26T01:02:59.853252"} +{"lr": 2.2635584844034485e-05, "step": 300, "loss": 1.041149616241455, "percent_done": 60.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137259483337402, "wps": 5540.2576804593755, "avg_wps": 4562.728358336017, "eta_in_seconds": 2872.667178630829, "at": "2024-05-26T01:03:11.683548"} +{"lr": 2.244340320030367e-05, "step": 301, "loss": 1.1909679174423218, "percent_done": 60.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5601.087634520706, "avg_wps": 4565.540265389221, "eta_in_seconds": 2856.54341915834, "at": "2024-05-26T01:03:37.980724"} +{"lr": 2.225155211184604e-05, "step": 302, "loss": 1.3130428791046143, "percent_done": 60.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5559.977785486543, "avg_wps": 4568.245761802313, "eta_in_seconds": 2840.50567254957, "at": "2024-05-26T01:03:49.768929"} +{"lr": 2.2060039970849715e-05, "step": 303, "loss": 1.327286720275879, "percent_done": 60.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139549255371094, "wps": 5553.915384460738, "avg_wps": 4570.923039338312, "eta_in_seconds": 2824.5043482221786, "at": "2024-05-26T01:04:01.569963"} +{"lr": 2.186887515467616e-05, "step": 304, "loss": 1.2636806964874268, "percent_done": 60.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13875722885132, "wps": 5535.986744465381, "avg_wps": 4573.545689597156, "eta_in_seconds": 2808.5553029932476, "at": "2024-05-26T01:04:13.409240"} +{"lr": 2.167806602549372e-05, "step": 305, "loss": 1.4129942655563354, "percent_done": 61.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5540.104255930096, "avg_wps": 4576.1633416315635, "eta_in_seconds": 2792.627589085063, "at": "2024-05-26T01:04:25.239781"} +{"lr": 2.148762092991183e-05, "step": 306, "loss": 1.423150658607483, "percent_done": 61.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139676094055176, "wps": 5547.69342100268, "avg_wps": 4578.783771293298, "eta_in_seconds": 2776.7164022268034, "at": "2024-05-26T01:04:37.054010"} +{"lr": 2.129754819861595e-05, "step": 307, "loss": 1.5841243267059326, "percent_done": 61.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13897943496704, "wps": 5521.223982083363, "avg_wps": 4581.331022280492, "eta_in_seconds": 2760.867516118463, "at": "2024-05-26T01:04:48.924937"} +{"lr": 2.1107856146003084e-05, "step": 308, "loss": 1.2460328340530396, "percent_done": 61.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.138951301574707, "wps": 5536.44847829994, "avg_wps": 4583.8985184096855, "eta_in_seconds": 2745.024120727143, "at": "2024-05-26T01:05:00.763195"} +{"lr": 2.0918553069818132e-05, "step": 309, "loss": 1.5161986351013184, "percent_done": 61.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1387357711792, "wps": 5527.5794176616155, "avg_wps": 4586.432518945001, "eta_in_seconds": 2729.2183954075313, "at": "2024-05-26T01:05:12.620454"} +{"lr": 2.0729647250790905e-05, "step": 310, "loss": 1.587321400642395, "percent_done": 62.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137510776519775, "wps": 5536.1954685024975, "avg_wps": 4588.972073396198, "eta_in_seconds": 2713.4268417512217, "at": "2024-05-26T01:05:24.459360"} +{"lr": 2.0541146952273892e-05, "step": 311, "loss": 1.3615864515304565, "percent_done": 62.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5534.504832792271, "avg_wps": 4591.494342811603, "eta_in_seconds": 2697.662912161021, "at": "2024-05-26T01:05:36.301703"} +{"lr": 2.0353060419880816e-05, "step": 312, "loss": 1.683513879776001, "percent_done": 62.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5535.882276859177, "avg_wps": 4594.006232537883, "eta_in_seconds": 2681.9223519410843, "at": "2024-05-26T01:05:48.141183"} +{"lr": 2.01653958811259e-05, "step": 313, "loss": 1.048714518547058, "percent_done": 62.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1375150680542, "wps": 5512.02102059552, "avg_wps": 4596.452011498966, "eta_in_seconds": 2666.2373433554894, "at": "2024-05-26T01:06:00.031899"} +{"lr": 1.997816154506404e-05, "step": 314, "loss": 1.4360339641571045, "percent_done": 62.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5529.866383223986, "avg_wps": 4598.924227720912, "eta_in_seconds": 2650.5537809308166, "at": "2024-05-26T01:06:11.884227"} +{"lr": 1.979136560193164e-05, "step": 315, "loss": 1.838736653327942, "percent_done": 63.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13912343978882, "wps": 5530.424455945281, "avg_wps": 4601.384609391944, "eta_in_seconds": 2634.8938480937295, "at": "2024-05-26T01:06:23.735460"} +{"lr": 1.9605016222788395e-05, "step": 316, "loss": 1.4693397283554077, "percent_done": 63.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5530.504682595344, "avg_wps": 4603.8322039696895, "eta_in_seconds": 2619.257928123957, "at": "2024-05-26T01:06:35.586409"} +{"lr": 1.9419121559159824e-05, "step": 317, "loss": 1.4064899682998657, "percent_done": 63.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792848587036, "wps": 5512.320132194016, "avg_wps": 4606.227012546687, "eta_in_seconds": 2603.6684617003434, "at": "2024-05-26T01:06:47.476488"} +{"lr": 1.9233689742680746e-05, "step": 318, "loss": 1.6543333530426025, "percent_done": 63.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13942050933838, "wps": 5526.7246545026865, "avg_wps": 4608.640808712972, "eta_in_seconds": 2588.084534045285, "at": "2024-05-26T01:06:59.335585"} +{"lr": 1.9048728884739516e-05, "step": 319, "loss": 1.408535122871399, "percent_done": 63.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5529.425767819157, "avg_wps": 4611.047869912337, "eta_in_seconds": 2572.520679605418, "at": "2024-05-26T01:07:11.188893"} +{"lr": 1.886424707612324e-05, "step": 320, "loss": 1.5866949558258057, "percent_done": 64.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.140464305877686, "wps": 5523.08539774153, "avg_wps": 4613.428570465795, "eta_in_seconds": 2556.9876762628555, "at": "2024-05-26T01:07:23.055887"} +{"lr": 1.86802523866639e-05, "step": 321, "loss": 1.4521435499191284, "percent_done": 64.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1387357711792, "wps": 5525.252361290496, "avg_wps": 4615.801587743876, "eta_in_seconds": 2541.4749262941964, "at": "2024-05-26T01:07:34.918107"} +{"lr": 1.8496752864885245e-05, "step": 322, "loss": 1.5227761268615723, "percent_done": 64.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14044427871704, "wps": 5525.6104474875965, "avg_wps": 4618.163062401021, "eta_in_seconds": 2525.9844319864833, "at": "2024-05-26T01:07:46.779612"} +{"lr": 1.831375653765083e-05, "step": 323, "loss": 1.3907850980758667, "percent_done": 64.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5527.902231483192, "avg_wps": 4620.517269233944, "eta_in_seconds": 2510.513720452601, "at": "2024-05-26T01:07:58.636159"} +{"lr": 1.813127140981282e-05, "step": 324, "loss": 1.3556586503982544, "percent_done": 64.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.138609886169434, "wps": 5512.704515043262, "avg_wps": 4622.8264284218185, "eta_in_seconds": 2495.083079279205, "at": "2024-05-26T01:08:10.525544"} +{"lr": 1.794930546386188e-05, "step": 325, "loss": 1.193861722946167, "percent_done": 65.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817262649536, "wps": 5516.623036431604, "avg_wps": 4625.132146359272, "eta_in_seconds": 2479.669690957436, "at": "2024-05-26T01:08:22.406274"} +{"lr": 1.7767866659577976e-05, "step": 326, "loss": 1.2673518657684326, "percent_done": 65.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13727045059204, "wps": 5518.114328739708, "avg_wps": 4627.429216642468, "eta_in_seconds": 2464.2762679088337, "at": "2024-05-26T01:08:34.283865"} +{"lr": 1.758696293368218e-05, "step": 327, "loss": 1.4862715005874634, "percent_done": 65.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5520.588377414058, "avg_wps": 4629.719822922852, "eta_in_seconds": 2448.901539109169, "at": "2024-05-26T01:08:46.156176"} +{"lr": 1.740660219948953e-05, "step": 328, "loss": 1.3229244947433472, "percent_done": 65.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1380033493042, "wps": 5513.1451232983945, "avg_wps": 4631.9827131895145, "eta_in_seconds": 2433.5565778133346, "at": "2024-05-26T01:08:58.044457"} +{"lr": 1.7226792346562806e-05, "step": 329, "loss": 1.0695526599884033, "percent_done": 65.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137794017791748, "wps": 5520.521521019695, "avg_wps": 4634.249861029113, "eta_in_seconds": 2418.2243806576657, "at": "2024-05-26T01:09:09.917024"} +{"lr": 1.7047541240367497e-05, "step": 330, "loss": 1.2772799730300903, "percent_done": 66.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1380033493042, "wps": 5524.147518129011, "avg_wps": 4636.51321436569, "eta_in_seconds": 2402.909144199256, "at": "2024-05-26T01:09:21.781632"} +{"lr": 1.6868856721927658e-05, "step": 331, "loss": 1.3015071153640747, "percent_done": 66.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5530.707095541982, "avg_wps": 4638.779041259455, "eta_in_seconds": 2387.6075798154234, "at": "2024-05-26T01:09:33.632306"} +{"lr": 1.669074660748301e-05, "step": 332, "loss": 1.2681198120117188, "percent_done": 66.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5533.303389441862, "avg_wps": 4641.038918298698, "eta_in_seconds": 2372.3239976699097, "at": "2024-05-26T01:09:45.477350"} +{"lr": 1.6513218688146936e-05, "step": 333, "loss": 1.077351689338684, "percent_done": 66.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1380033493042, "wps": 5532.607539599817, "avg_wps": 4643.285933992912, "eta_in_seconds": 2357.0618212151453, "at": "2024-05-26T01:09:57.323944"} +{"lr": 1.6336280729565724e-05, "step": 334, "loss": 1.0104950666427612, "percent_done": 66.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.141358852386475, "wps": 5545.151396999249, "avg_wps": 4645.548070660843, "eta_in_seconds": 2341.8067867398977, "at": "2024-05-26T01:10:09.143782"} +{"lr": 1.6159940471578926e-05, "step": 335, "loss": 1.0948432683944702, "percent_done": 67.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5540.053562938807, "avg_wps": 4647.788186973401, "eta_in_seconds": 2326.577624666157, "at": "2024-05-26T01:10:20.974382"} +{"lr": 1.598420562788065e-05, "step": 336, "loss": 1.62564218044281, "percent_done": 67.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817262649536, "wps": 5530.313077173483, "avg_wps": 4649.996652415117, "eta_in_seconds": 2311.378868287518, "at": "2024-05-26T01:10:32.825821"} +{"lr": 1.5809083885682293e-05, "step": 337, "loss": 1.3993029594421387, "percent_done": 67.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13819980621338, "wps": 5540.200954825271, "avg_wps": 4652.214818345599, "eta_in_seconds": 2296.189754152156, "at": "2024-05-26T01:10:44.656133"} +{"lr": 1.5634582905376138e-05, "step": 338, "loss": 1.1360607147216797, "percent_done": 67.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5536.252892672875, "avg_wps": 4654.413707475299, "eta_in_seconds": 2281.0245644792294, "at": "2024-05-26T01:10:56.494858"} +{"lr": 1.546071032020041e-05, "step": 339, "loss": 1.3813202381134033, "percent_done": 67.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13995599746704, "wps": 5521.306049180372, "avg_wps": 4656.570407886061, "eta_in_seconds": 2265.8942259588775, "at": "2024-05-26T01:11:08.365761"} +{"lr": 1.5287473735905225e-05, "step": 340, "loss": 1.1545019149780273, "percent_done": 68.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13843536376953, "wps": 5539.6732834303475, "avg_wps": 4658.754737015351, "eta_in_seconds": 2250.764548021204, "at": "2024-05-26T01:11:20.197153"} +{"lr": 1.5114880730419973e-05, "step": 341, "loss": 1.9393445253372192, "percent_done": 68.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5535.765549843778, "avg_wps": 4660.920168987583, "eta_in_seconds": 2235.658115179308, "at": "2024-05-26T01:11:32.036940"} +{"lr": 1.4942938853521888e-05, "step": 342, "loss": 1.5955932140350342, "percent_done": 68.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137256622314453, "wps": 5529.3659269621685, "avg_wps": 4663.061641067549, "eta_in_seconds": 2220.577122293718, "at": "2024-05-26T01:11:43.890427"} +{"lr": 1.4771655626505637e-05, "step": 343, "loss": 1.489546298980713, "percent_done": 68.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963747024536, "wps": 5535.5605369446, "avg_wps": 4665.205419675395, "eta_in_seconds": 2205.508884261718, "at": "2024-05-26T01:11:55.730795"} +{"lr": 1.4601038541854481e-05, "step": 344, "loss": 1.368099570274353, "percent_done": 68.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13988208770752, "wps": 5541.010410055027, "avg_wps": 4667.3499410081895, "eta_in_seconds": 2190.4541397621465, "at": "2024-05-26T01:12:07.559306"} +{"lr": 1.4431095062912406e-05, "step": 345, "loss": 1.371695637702942, "percent_done": 69.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5539.930407399604, "avg_wps": 4669.481762154883, "eta_in_seconds": 2175.4191401557646, "at": "2024-05-26T01:12:19.390170"} +{"lr": 1.426183262355772e-05, "step": 346, "loss": 1.3988710641860962, "percent_done": 69.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.140594959259033, "wps": 5530.285483525829, "avg_wps": 4671.583335669962, "eta_in_seconds": 2160.411850718405, "at": "2024-05-26T01:12:31.241703"} +{"lr": 1.4093258627877864e-05, "step": 347, "loss": 1.3253638744354248, "percent_done": 69.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14137363433838, "wps": 5546.714341652883, "avg_wps": 4673.708386916458, "eta_in_seconds": 2145.4072804519697, "at": "2024-05-26T01:12:43.058109"} +{"lr": 1.392538044984549e-05, "step": 348, "loss": 1.4922512769699097, "percent_done": 69.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5538.872031475573, "avg_wps": 4675.80710581218, "eta_in_seconds": 2130.428346288615, "at": "2024-05-26T01:12:54.891399"} +{"lr": 1.3758205432995999e-05, "step": 349, "loss": 1.6032309532165527, "percent_done": 69.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 2799.847247287034, "avg_wps": 4666.847531236229, "eta_in_seconds": 2120.475531665507, "at": "2024-05-26T01:13:18.299547"} +{"lr": 1.3591740890106174e-05, "step": 350, "loss": 1.3721952438354492, "percent_done": 70.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1370267868042, "wps": 5549.921649644395, "avg_wps": 4668.970107745052, "eta_in_seconds": 2105.4750347818645, "at": "2024-05-26T01:13:30.109046"} +{"lr": 1.342599410287438e-05, "step": 351, "loss": 1.2236526012420654, "percent_done": 70.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1384916305542, "wps": 5549.655530169466, "avg_wps": 4671.081967881481, "eta_in_seconds": 2090.492966542556, "at": "2024-05-26T01:13:41.919144"} +{"lr": 1.3260972321602061e-05, "step": 352, "loss": 1.4053864479064941, "percent_done": 70.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5543.081359716434, "avg_wps": 4673.170465039946, "eta_in_seconds": 2075.5348157232456, "at": "2024-05-26T01:13:53.743310"} +{"lr": 1.3096682764876501e-05, "step": 353, "loss": 1.396177887916565, "percent_done": 70.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.141611099243164, "wps": 5543.549979543282, "avg_wps": 4675.249926233429, "eta_in_seconds": 2060.5940114438704, "at": "2024-05-26T01:14:05.566377"} +{"lr": 1.2933132619255162e-05, "step": 354, "loss": 1.6633139848709106, "percent_done": 70.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13971185684204, "wps": 5532.296980664749, "avg_wps": 4677.296799001518, "eta_in_seconds": 2045.6807449214202, "at": "2024-05-26T01:14:17.413596"} +{"lr": 1.2770329038951215e-05, "step": 355, "loss": 1.4951876401901245, "percent_done": 71.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139026641845703, "wps": 5536.351241300769, "avg_wps": 4679.342082409068, "eta_in_seconds": 2030.7812151035791, "at": "2024-05-26T01:14:29.252008"} +{"lr": 1.2608279145520686e-05, "step": 356, "loss": 1.7069875001907349, "percent_done": 71.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13854217529297, "wps": 5521.726625886975, "avg_wps": 4681.348200228023, "eta_in_seconds": 2015.9115699918082, "at": "2024-05-26T01:14:41.121917"} +{"lr": 1.2446990027550896e-05, "step": 357, "loss": 1.1795735359191895, "percent_done": 71.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5523.999313996375, "avg_wps": 4683.349363497956, "eta_in_seconds": 2001.0567806541753, "at": "2024-05-26T01:14:52.986808"} +{"lr": 1.2286468740350344e-05, "step": 358, "loss": 1.3241490125656128, "percent_done": 71.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1397123336792, "wps": 5535.469685077949, "avg_wps": 4685.364046674451, "eta_in_seconds": 1986.208949250216, "at": "2024-05-26T01:15:04.827224"} +{"lr": 1.2126722305640172e-05, "step": 359, "loss": 1.286388874053955, "percent_done": 71.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5531.542052526424, "avg_wps": 4687.361375192172, "eta_in_seconds": 1971.3811802319497, "at": "2024-05-26T01:15:16.676016"} +{"lr": 1.1967757711246922e-05, "step": 360, "loss": 1.0435327291488647, "percent_done": 72.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5527.839977949607, "avg_wps": 4689.341901413824, "eta_in_seconds": 1956.5730528699028, "at": "2024-05-26T01:15:28.532745"} +{"lr": 1.1809581910796943e-05, "step": 361, "loss": 1.5640085935592651, "percent_done": 72.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14134693145752, "wps": 5527.675457503188, "avg_wps": 4691.312787399688, "eta_in_seconds": 1941.781418725064, "at": "2024-05-26T01:15:40.389878"} +{"lr": 1.1652201823412147e-05, "step": 362, "loss": 1.3622779846191406, "percent_done": 72.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5525.521810167331, "avg_wps": 4693.2701377464045, "eta_in_seconds": 1927.007765281266, "at": "2024-05-26T01:15:52.251513"} +{"lr": 1.1495624333407409e-05, "step": 363, "loss": 1.2254904508590698, "percent_done": 72.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5529.940029910749, "avg_wps": 4695.227105628912, "eta_in_seconds": 1912.2465853113115, "at": "2024-05-26T01:16:04.103751"} +{"lr": 1.133985628998939e-05, "step": 364, "loss": 1.4732694625854492, "percent_done": 72.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5531.145132715192, "avg_wps": 4697.177328338779, "eta_in_seconds": 1897.5004299341979, "at": "2024-05-26T01:16:15.953430"} +{"lr": 1.1184904506956906e-05, "step": 365, "loss": 1.7372241020202637, "percent_done": 73.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137560844421387, "wps": 5518.700833643773, "avg_wps": 4699.09380878566, "eta_in_seconds": 1882.7800337713059, "at": "2024-05-26T01:16:27.829813"} +{"lr": 1.1030775762402946e-05, "step": 366, "loss": 1.1547083854675293, "percent_done": 73.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5529.9827503379865, "avg_wps": 4701.023689902065, "eta_in_seconds": 1868.0663147611044, "at": "2024-05-26T01:16:39.682168"} +{"lr": 1.0877476798418077e-05, "step": 367, "loss": 1.304084062576294, "percent_done": 73.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137547969818115, "wps": 5529.8643807734925, "avg_wps": 4702.944393558633, "eta_in_seconds": 1853.3682881596953, "at": "2024-05-26T01:16:51.534592"} +{"lr": 1.0725014320795634e-05, "step": 368, "loss": 1.2010260820388794, "percent_done": 73.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5526.495643780223, "avg_wps": 4704.849585446528, "eta_in_seconds": 1838.6883242259855, "at": "2024-05-26T01:17:03.394351"} +{"lr": 1.0573394998738269e-05, "step": 369, "loss": 1.5033233165740967, "percent_done": 73.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1399564743042, "wps": 5507.461435735282, "avg_wps": 4706.708438388072, "eta_in_seconds": 1824.0382025745826, "at": "2024-05-26T01:17:15.294947"} +{"lr": 1.0422625464566322e-05, "step": 370, "loss": 1.3334954977035522, "percent_done": 74.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13773012161255, "wps": 5522.791219683612, "avg_wps": 4708.588900724632, "eta_in_seconds": 1809.3913441219845, "at": "2024-05-26T01:17:27.162559"} +{"lr": 1.0272712313427651e-05, "step": 371, "loss": 1.3419601917266846, "percent_done": 74.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5529.395736000402, "avg_wps": 4710.47365162892, "eta_in_seconds": 1794.7545459842424, "at": "2024-05-26T01:17:39.016142"} +{"lr": 1.0123662103009122e-05, "step": 372, "loss": 1.3665707111358643, "percent_done": 74.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13747549057007, "wps": 5522.847256467364, "avg_wps": 4712.336966156755, "eta_in_seconds": 1780.1375538815735, "at": "2024-05-26T01:17:50.907777"} +{"lr": 9.97548135324981e-06, "step": 373, "loss": 1.5524204969406128, "percent_done": 74.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139872074127197, "wps": 5532.042791465737, "avg_wps": 4714.209684888793, "eta_in_seconds": 1765.5285946824274, "at": "2024-05-26T01:18:02.755547"} +{"lr": 9.828176546055728e-06, "step": 374, "loss": 1.3623601198196411, "percent_done": 74.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5514.188711466234, "avg_wps": 4716.039060005281, "eta_in_seconds": 1750.947329938093, "at": "2024-05-26T01:18:14.641646"} +{"lr": 9.681754125016368e-06, "step": 375, "loss": 1.293965458869934, "percent_done": 75.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5525.246475025507, "avg_wps": 4717.881629896226, "eta_in_seconds": 1736.3725168704987, "at": "2024-05-26T01:18:26.503964"} +{"lr": 9.536220495122747e-06, "step": 376, "loss": 1.1819424629211426, "percent_done": 75.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5532.530815271963, "avg_wps": 4719.729945333812, "eta_in_seconds": 1721.80698771426, "at": "2024-05-26T01:18:38.350780"} +{"lr": 9.391582022487311e-06, "step": 377, "loss": 1.5811065435409546, "percent_done": 75.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5533.474483046087, "avg_wps": 4721.571715420697, "eta_in_seconds": 1707.2552289469488, "at": "2024-05-26T01:18:50.195408"} +{"lr": 9.247845034065422e-06, "step": 378, "loss": 1.3237336874008179, "percent_done": 75.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841676712036, "wps": 5511.9933881242905, "avg_wps": 4723.3635987550615, "eta_in_seconds": 1692.7326962733393, "at": "2024-05-26T01:19:02.086237"} +{"lr": 9.105015817378586e-06, "step": 379, "loss": 1.3288097381591797, "percent_done": 75.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5528.435557153815, "avg_wps": 4725.1791625702135, "eta_in_seconds": 1678.2127676374994, "at": "2024-05-26T01:19:13.941709"} +{"lr": 8.963100620239454e-06, "step": 380, "loss": 1.3023933172225952, "percent_done": 76.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137242794036865, "wps": 5520.170523800052, "avg_wps": 4726.970631263569, "eta_in_seconds": 1663.7124732670031, "at": "2024-05-26T01:19:25.815220"} +{"lr": 8.82210565047849e-06, "step": 381, "loss": 1.1715354919433594, "percent_done": 76.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1399564743042, "wps": 5506.105486671179, "avg_wps": 4728.726885406522, "eta_in_seconds": 1649.235447297259, "at": "2024-05-26T01:19:37.718827"} +{"lr": 8.682037075672413e-06, "step": 382, "loss": 1.1838302612304688, "percent_done": 76.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5528.568988047758, "avg_wps": 4730.518468300828, "eta_in_seconds": 1634.756962015991, "at": "2024-05-26T01:19:49.574183"} +{"lr": 8.542901022874465e-06, "step": 383, "loss": 1.512841820716858, "percent_done": 76.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5525.2364795099165, "avg_wps": 4732.295664116231, "eta_in_seconds": 1620.294365405414, "at": "2024-05-26T01:20:01.436485"} +{"lr": 8.404703578346311e-06, "step": 384, "loss": 1.6261485815048218, "percent_done": 76.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1397123336792, "wps": 5530.608502228467, "avg_wps": 4734.075189238517, "eta_in_seconds": 1605.8418373415868, "at": "2024-05-26T01:20:13.287311"} +{"lr": 8.267450787291907e-06, "step": 385, "loss": 1.2234678268432617, "percent_done": 77.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5536.221114101282, "avg_wps": 4735.857477097785, "eta_in_seconds": 1591.3992421534156, "at": "2024-05-26T01:20:25.126278"} +{"lr": 8.13114865359295e-06, "step": 386, "loss": 1.6184728145599365, "percent_done": 77.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139348030090332, "wps": 5526.538199892597, "avg_wps": 4737.613460043199, "eta_in_seconds": 1576.9762693835046, "at": "2024-05-26T01:20:36.985919"} +{"lr": 7.995803139546319e-06, "step": 387, "loss": 1.0855679512023926, "percent_done": 77.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5536.265269688946, "avg_wps": 4739.380112679149, "eta_in_seconds": 1562.5604665445726, "at": "2024-05-26T01:20:48.824605"} +{"lr": 7.861420165603275e-06, "step": 388, "loss": 1.6422431468963623, "percent_done": 77.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14134693145752, "wps": 5526.940126363365, "avg_wps": 4741.121311001862, "eta_in_seconds": 1548.1637187741467, "at": "2024-05-26T01:21:00.683489"} +{"lr": 7.728005610110419e-06, "step": 389, "loss": 1.691611886024475, "percent_done": 77.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5528.500603910024, "avg_wps": 4742.857780377795, "eta_in_seconds": 1533.7790709424446, "at": "2024-05-26T01:21:12.538764"} +{"lr": 7.59556530905263e-06, "step": 390, "loss": 1.298542857170105, "percent_done": 78.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.140429973602295, "wps": 5532.2326239417325, "avg_wps": 4744.59365064626, "eta_in_seconds": 1519.4051442146301, "at": "2024-05-26T01:21:24.386260"} +{"lr": 7.464105055797707e-06, "step": 391, "loss": 1.1656980514526367, "percent_done": 78.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5535.855631003735, "avg_wps": 4746.328719039921, "eta_in_seconds": 1505.0419856812948, "at": "2024-05-26T01:21:36.225912"} +{"lr": 7.333630600843008e-06, "step": 392, "loss": 1.1147528886795044, "percent_done": 78.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1370267868042, "wps": 5524.541213566124, "avg_wps": 4748.034918572801, "eta_in_seconds": 1490.6983881507601, "at": "2024-05-26T01:21:48.089824"} +{"lr": 7.204147651563878e-06, "step": 393, "loss": 1.438295841217041, "percent_done": 78.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5526.148330405151, "avg_wps": 4749.736674789495, "eta_in_seconds": 1476.366476739636, "at": "2024-05-26T01:21:59.950307"} +{"lr": 7.07566187196397e-06, "step": 394, "loss": 1.6418980360031128, "percent_done": 78.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139430046081543, "wps": 5526.016904899557, "avg_wps": 4751.430757068726, "eta_in_seconds": 1462.0471927671867, "at": "2024-05-26T01:22:11.811073"} +{"lr": 6.948178882427538e-06, "step": 395, "loss": 1.5248198509216309, "percent_done": 79.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5539.695165392135, "avg_wps": 4753.143017563693, "eta_in_seconds": 1447.732579173921, "at": "2024-05-26T01:22:23.642574"} +{"lr": 6.821704259473511e-06, "step": 396, "loss": 1.4680887460708618, "percent_done": 79.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1380033493042, "wps": 5518.337770856426, "avg_wps": 4754.807968729612, "eta_in_seconds": 1433.4425374955842, "at": "2024-05-26T01:22:35.519833"} +{"lr": 6.696243535511637e-06, "step": 397, "loss": 1.472925066947937, "percent_done": 79.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137734413146973, "wps": 5517.009791321851, "avg_wps": 4756.463204499338, "eta_in_seconds": 1419.165398696808, "at": "2024-05-26T01:22:47.399807"} +{"lr": 6.571802198600406e-06, "step": 398, "loss": 1.1985504627227783, "percent_done": 79.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5527.859543194786, "avg_wps": 4758.131503702449, "eta_in_seconds": 1404.8943361061902, "at": "2024-05-26T01:22:59.256654"} +{"lr": 6.4483856922070286e-06, "step": 399, "loss": 1.4447048902511597, "percent_done": 79.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1397123336792, "wps": 5535.095050174162, "avg_wps": 4759.806029795003, "eta_in_seconds": 1390.6314582077782, "at": "2024-05-26T01:23:11.097976"} +{"lr": 6.325999414969323e-06, "step": 400, "loss": 1.5511690378189087, "percent_done": 80.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13890552520752, "wps": 5517.873403748047, "avg_wps": 4761.441394141816, "eta_in_seconds": 1376.389932692051, "at": "2024-05-26T01:23:22.976216"} +{"lr": 6.2046487204595115e-06, "step": 401, "loss": 1.290692687034607, "percent_done": 80.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841962814331, "wps": 5598.55335408203, "avg_wps": 4763.2174792128435, "eta_in_seconds": 1362.1179440818225, "at": "2024-05-26T01:23:50.044411"} +{"lr": 6.084338916950114e-06, "step": 402, "loss": 1.6321139335632324, "percent_done": 80.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5559.21089959873, "avg_wps": 4764.914649424374, "eta_in_seconds": 1347.8789175742893, "at": "2024-05-26T01:24:01.834274"} +{"lr": 5.965075267181666e-06, "step": 403, "loss": 1.2665281295776367, "percent_done": 80.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13898754119873, "wps": 5541.611847253161, "avg_wps": 4766.572390819128, "eta_in_seconds": 1333.6610626630097, "at": "2024-05-26T01:24:13.661546"} +{"lr": 5.846862988132589e-06, "step": 404, "loss": 1.478092908859253, "percent_done": 80.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14134693145752, "wps": 5536.284560103616, "avg_wps": 4768.213298916344, "eta_in_seconds": 1319.4577519067443, "at": "2024-05-26T01:24:25.500261"} +{"lr": 5.7297072507909045e-06, "step": 405, "loss": 1.8101279735565186, "percent_done": 81.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792848587036, "wps": 5522.525920368058, "avg_wps": 4769.821945925478, "eta_in_seconds": 1305.2730417575365, "at": "2024-05-26T01:24:37.368321"} +{"lr": 5.613613179928103e-06, "step": 406, "loss": 1.4218931198120117, "percent_done": 81.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137152671813965, "wps": 5537.558917220902, "avg_wps": 4771.451311582195, "eta_in_seconds": 1291.092289896434, "at": "2024-05-26T01:24:49.204305"} +{"lr": 5.498585853874947e-06, "step": 407, "loss": 1.4505722522735596, "percent_done": 81.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139375686645508, "wps": 5534.44844776445, "avg_wps": 4773.068094762466, "eta_in_seconds": 1276.9245858210018, "at": "2024-05-26T01:25:01.046787"} +{"lr": 5.384630304299297e-06, "step": 408, "loss": 1.7245798110961914, "percent_done": 81.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792848587036, "wps": 5529.601516113697, "avg_wps": 4774.669190890225, "eta_in_seconds": 1262.7706253458473, "at": "2024-05-26T01:25:12.899780"} +{"lr": 5.271751515986073e-06, "step": 409, "loss": 1.5155235528945923, "percent_done": 81.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13807201385498, "wps": 5527.431251628049, "avg_wps": 4776.2595638576395, "eta_in_seconds": 1248.6289575064968, "at": "2024-05-26T01:25:24.757450"} +{"lr": 5.159954426619136e-06, "step": 410, "loss": 1.1947604417800903, "percent_done": 82.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1372709274292, "wps": 5534.080078998145, "avg_wps": 4777.855332981898, "eta_in_seconds": 1234.495309911123, "at": "2024-05-26T01:25:36.600760"} +{"lr": 5.049243926565364e-06, "step": 411, "loss": 1.4178783893585205, "percent_done": 82.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13890552520752, "wps": 5524.907980357002, "avg_wps": 4779.427722849318, "eta_in_seconds": 1220.3770698561286, "at": "2024-05-26T01:25:48.463751"} +{"lr": 4.939624858660665e-06, "step": 412, "loss": 1.444692611694336, "percent_done": 82.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5532.407882614163, "avg_wps": 4781.007120603711, "eta_in_seconds": 1206.2663481814188, "at": "2024-05-26T01:26:00.310831"} +{"lr": 4.831102017998196e-06, "step": 413, "loss": 1.3638207912445068, "percent_done": 82.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139493942260742, "wps": 5535.21029990303, "avg_wps": 4782.584974826806, "eta_in_seconds": 1192.165331094086, "at": "2024-05-26T01:26:12.151762"} +{"lr": 4.7236801517185786e-06, "step": 414, "loss": 1.175404667854309, "percent_done": 82.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14134693145752, "wps": 5531.479605673014, "avg_wps": 4784.149504495401, "eta_in_seconds": 1178.0768963645623, "at": "2024-05-26T01:26:24.000761"} +{"lr": 4.617363958802224e-06, "step": 415, "loss": 1.4109824895858765, "percent_done": 83.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5522.800096722068, "avg_wps": 4785.691831132305, "eta_in_seconds": 1164.0030734452857, "at": "2024-05-26T01:26:35.868225"} +{"lr": 4.512158089863847e-06, "step": 416, "loss": 1.238850474357605, "percent_done": 83.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5528.04275175627, "avg_wps": 4787.237190444588, "eta_in_seconds": 1149.937590514238, "at": "2024-05-26T01:26:47.724487"} +{"lr": 4.408067146948968e-06, "step": 417, "loss": 1.3194738626480103, "percent_done": 83.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13749408721924, "wps": 5522.282280213682, "avg_wps": 4788.7657519447175, "eta_in_seconds": 1135.8851699503205, "at": "2024-05-26T01:26:59.593137"} +{"lr": 4.305095683332627e-06, "step": 418, "loss": 1.1203041076660156, "percent_done": 83.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5534.156177782416, "avg_wps": 4790.309298286976, "eta_in_seconds": 1121.8382082179403, "at": "2024-05-26T01:27:11.436318"} +{"lr": 4.20324820332023e-06, "step": 419, "loss": 1.1515454053878784, "percent_done": 83.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5529.878175461868, "avg_wps": 4791.838804481042, "eta_in_seconds": 1107.8035419379896, "at": "2024-05-26T01:27:23.288760"} +{"lr": 4.102529162050497e-06, "step": 420, "loss": 1.3843259811401367, "percent_done": 84.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5531.054425724364, "avg_wps": 4793.364101187676, "eta_in_seconds": 1093.7787927900042, "at": "2024-05-26T01:27:35.138532"} +{"lr": 4.002942965300582e-06, "step": 421, "loss": 1.2896846532821655, "percent_done": 84.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13866138458252, "wps": 5533.5867689741135, "avg_wps": 4794.887634639773, "eta_in_seconds": 1079.7633635035038, "at": "2024-05-26T01:27:46.982964"} +{"lr": 3.90449396929334e-06, "step": 422, "loss": 1.2825158834457397, "percent_done": 84.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5528.319032774927, "avg_wps": 4796.395522130321, "eta_in_seconds": 1065.7603144724787, "at": "2024-05-26T01:27:58.838668"} +{"lr": 3.8071864805067762e-06, "step": 423, "loss": 1.3010966777801514, "percent_done": 84.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139546394348145, "wps": 5529.526098704965, "avg_wps": 4797.899370981466, "eta_in_seconds": 1051.7669525377576, "at": "2024-05-26T01:28:10.691912"} +{"lr": 3.711024755485704e-06, "step": 424, "loss": 1.4910497665405273, "percent_done": 84.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817262649536, "wps": 5536.696381195103, "avg_wps": 4799.409786353237, "eta_in_seconds": 1037.7809400985825, "at": "2024-05-26T01:28:22.529706"} +{"lr": 3.6160130006554755e-06, "step": 425, "loss": 1.4145011901855469, "percent_done": 85.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5539.8051360317895, "avg_wps": 4800.919535145401, "eta_in_seconds": 1023.8038700748892, "at": "2024-05-26T01:28:34.360845"} +{"lr": 3.522155372138053e-06, "step": 426, "loss": 1.562549352645874, "percent_done": 85.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1397123336792, "wps": 5533.877530500427, "avg_wps": 4802.412671329722, "eta_in_seconds": 1009.8390812918614, "at": "2024-05-26T01:28:46.204751"} +{"lr": 3.4294559755701608e-06, "step": 427, "loss": 1.6161084175109863, "percent_done": 85.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1399564743042, "wps": 5522.926153747918, "avg_wps": 4803.880370958066, "eta_in_seconds": 995.888246702087, "at": "2024-05-26T01:28:58.072083"} +{"lr": 3.337918865923721e-06, "step": 428, "loss": 1.4051026105880737, "percent_done": 85.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13795518875122, "wps": 5522.344741464484, "avg_wps": 4805.3410747971175, "eta_in_seconds": 981.9473636841105, "at": "2024-05-26T01:29:09.940752"} +{"lr": 3.2475480473284393e-06, "step": 429, "loss": 1.441631555557251, "percent_done": 85.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5521.300393126491, "avg_wps": 4806.794006461246, "eta_in_seconds": 968.0165186495213, "at": "2024-05-26T01:29:21.811505"} +{"lr": 3.158347472896674e-06, "step": 430, "loss": 1.296938180923462, "percent_done": 86.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13873529434204, "wps": 5530.113251980821, "avg_wps": 4808.256571451793, "eta_in_seconds": 954.0921811946603, "at": "2024-05-26T01:29:33.663367"} +{"lr": 3.0703210445505373e-06, "step": 431, "loss": 1.2587578296661377, "percent_done": 86.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1370267868042, "wps": 5529.654798974455, "avg_wps": 4809.71242902935, "eta_in_seconds": 940.1776232415175, "at": "2024-05-26T01:29:45.516228"} +{"lr": 2.9834726128511543e-06, "step": 432, "loss": 0.9100736379623413, "percent_done": 86.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5535.013352838121, "avg_wps": 4811.171803270384, "eta_in_seconds": 926.2708093214918, "at": "2024-05-26T01:29:57.357596"} +{"lr": 2.897805976830286e-06, "step": 433, "loss": 1.4476325511932373, "percent_done": 86.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137044429779053, "wps": 5540.317533962669, "avg_wps": 4812.634568642638, "eta_in_seconds": 912.3717866736802, "at": "2024-05-26T01:30:09.187761"} +{"lr": 2.8133248838241186e-06, "step": 434, "loss": 1.1574301719665527, "percent_done": 86.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1382474899292, "wps": 5536.409226256145, "avg_wps": 4814.084672754298, "eta_in_seconds": 898.4835735191398, "at": "2024-05-26T01:30:21.026124"} +{"lr": 2.7300330293093305e-06, "step": 435, "loss": 1.352285385131836, "percent_done": 87.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139604568481445, "wps": 5525.974467905801, "avg_wps": 4815.510795797779, "eta_in_seconds": 884.6081299864012, "at": "2024-05-26T01:30:32.886969"} +{"lr": 2.6479340567414757e-06, "step": 436, "loss": 1.0167021751403809, "percent_done": 87.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13966131210327, "wps": 5527.076819131005, "avg_wps": 4816.93313713064, "eta_in_seconds": 870.7415861077264, "at": "2024-05-26T01:30:44.745338"} +{"lr": 2.5670315573955692e-06, "step": 437, "loss": 1.5493172407150269, "percent_done": 87.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1399564743042, "wps": 5508.993597610047, "avg_wps": 4818.318252074068, "eta_in_seconds": 856.8898491133814, "at": "2024-05-26T01:30:56.642640"} +{"lr": 2.48732907020903e-06, "step": 438, "loss": 1.7014528512954712, "percent_done": 87.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1406888961792, "wps": 5533.007342301095, "avg_wps": 4819.739616271812, "eta_in_seconds": 843.0397331594877, "at": "2024-05-26T01:31:08.488447"} +{"lr": 2.4088300816268335e-06, "step": 439, "loss": 1.4381757974624634, "percent_done": 87.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5526.920789883583, "avg_wps": 4821.144799977807, "eta_in_seconds": 829.200566641019, "at": "2024-05-26T01:31:20.347121"} +{"lr": 2.3315380254490547e-06, "step": 440, "loss": 1.1990140676498413, "percent_done": 88.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1370267868042, "wps": 5531.856757145654, "avg_wps": 4822.5529438318035, "eta_in_seconds": 815.368964487856, "at": "2024-05-26T01:31:32.195255"} +{"lr": 2.2554562826806213e-06, "step": 441, "loss": 1.2472739219665527, "percent_done": 88.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.137741088867188, "wps": 5522.19951845925, "avg_wps": 4823.938837216493, "eta_in_seconds": 801.5491345307184, "at": "2024-05-26T01:31:44.064138"} +{"lr": 2.1805881813834265e-06, "step": 442, "loss": 1.6326481103897095, "percent_done": 88.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14134645462036, "wps": 5529.34334794191, "avg_wps": 4825.331575668181, "eta_in_seconds": 787.736125568459, "at": "2024-05-26T01:31:55.917841"} +{"lr": 2.106936996530766e-06, "step": 443, "loss": 1.249131441116333, "percent_done": 88.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13866090774536, "wps": 5528.971321179561, "avg_wps": 4826.718185394002, "eta_in_seconds": 773.9320707192002, "at": "2024-05-26T01:32:07.772114"} +{"lr": 2.034505949864056e-06, "step": 444, "loss": 1.2009150981903076, "percent_done": 88.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139052867889404, "wps": 5528.53562972045, "avg_wps": 4828.098592562468, "eta_in_seconds": 760.1369213241715, "at": "2024-05-26T01:32:19.627373"} +{"lr": 1.9632982097519294e-06, "step": 445, "loss": 1.6638498306274414, "percent_done": 89.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5521.438470694523, "avg_wps": 4829.461394149607, "eta_in_seconds": 746.3523788318206, "at": "2024-05-26T01:32:31.497940"} +{"lr": 1.8933168910516103e-06, "step": 446, "loss": 1.8934630155563354, "percent_done": 89.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5530.25655499734, "avg_wps": 4830.83395961315, "eta_in_seconds": 732.5741330764754, "at": "2024-05-26T01:32:43.349501"} +{"lr": 1.8245650549726923e-06, "step": 447, "loss": 1.3426645994186401, "percent_done": 89.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5529.773715784365, "avg_wps": 4832.200334250932, "eta_in_seconds": 718.8046355156824, "at": "2024-05-26T01:32:55.202219"} +{"lr": 1.757045708943213e-06, "step": 448, "loss": 1.1059918403625488, "percent_done": 89.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1387357711792, "wps": 5530.425568642956, "avg_wps": 4833.562488571657, "eta_in_seconds": 705.0435383958476, "at": "2024-05-26T01:33:07.053394"} +{"lr": 1.6907618064780943e-06, "step": 449, "loss": 1.1673721075057983, "percent_done": 89.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5534.731944596605, "avg_wps": 4834.926663134462, "eta_in_seconds": 691.2899063153893, "at": "2024-05-26T01:33:18.895326"} +{"lr": 1.625716247049965e-06, "step": 450, "loss": 1.5422428846359253, "percent_done": 90.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.141543865203857, "wps": 5529.564252092678, "avg_wps": 4836.276763342187, "eta_in_seconds": 677.5460049841139, "at": "2024-05-26T01:33:30.748325"} +{"lr": 1.5619118759623072e-06, "step": 451, "loss": 1.575745701789856, "percent_done": 90.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1389799118042, "wps": 5526.203324335761, "avg_wps": 4837.615918344345, "eta_in_seconds": 663.8112769190329, "at": "2024-05-26T01:33:42.608553"} +{"lr": 1.4993514842250177e-06, "step": 452, "loss": 1.3347529172897339, "percent_done": 90.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5530.399420365948, "avg_wps": 4838.956997357865, "eta_in_seconds": 650.0838924002858, "at": "2024-05-26T01:33:54.459897"} +{"lr": 1.4380378084322957e-06, "step": 453, "loss": 1.3280354738235474, "percent_done": 90.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13995599746704, "wps": 5504.600614814582, "avg_wps": 4840.249065640305, "eta_in_seconds": 636.370558256082, "at": "2024-05-26T01:34:06.366570"} +{"lr": 1.37797353064294e-06, "step": 454, "loss": 1.8662519454956055, "percent_done": 90.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13873529434204, "wps": 5521.9309481375085, "avg_wps": 4841.565565280686, "eta_in_seconds": 622.661401431466, "at": "2024-05-26T01:34:18.235992"} +{"lr": 1.319161278263055e-06, "step": 455, "loss": 1.2935104370117188, "percent_done": 91.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1375150680542, "wps": 5524.135750319221, "avg_wps": 4842.880715456137, "eta_in_seconds": 608.9598677472753, "at": "2024-05-26T01:34:30.100636"} +{"lr": 1.261603623931077e-06, "step": 456, "loss": 1.1133410930633545, "percent_done": 91.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5543.254847133117, "avg_wps": 4844.2229380055915, "eta_in_seconds": 595.2624470225552, "at": "2024-05-26T01:34:41.924339"} +{"lr": 1.205303085405276e-06, "step": 457, "loss": 0.9698067307472229, "percent_done": 91.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1380033493042, "wps": 5522.029897897316, "avg_wps": 4845.524401093386, "eta_in_seconds": 581.5775067326276, "at": "2024-05-26T01:34:53.793598"} +{"lr": 1.1502621254535857e-06, "step": 458, "loss": 1.4360275268554688, "percent_done": 91.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792848587036, "wps": 5529.291294548543, "avg_wps": 4846.833074219196, "eta_in_seconds": 567.8990709708768, "at": "2024-05-26T01:35:05.647166"} +{"lr": 1.0964831517459112e-06, "step": 459, "loss": 1.423099160194397, "percent_done": 91.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1389799118042, "wps": 5525.477159361278, "avg_wps": 4848.130354698634, "eta_in_seconds": 554.229322112983, "at": "2024-05-26T01:35:17.508882"} +{"lr": 1.0439685167487763e-06, "step": 460, "loss": 1.366470217704773, "percent_done": 92.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5531.416937610161, "avg_wps": 4849.432620379425, "eta_in_seconds": 540.5663311999776, "at": "2024-05-26T01:35:29.357901"} +{"lr": 9.927205176224375e-07, "step": 461, "loss": 1.4344816207885742, "percent_done": 92.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5532.91033750688, "avg_wps": 4850.732422140273, "eta_in_seconds": 526.9109440739398, "at": "2024-05-26T01:35:41.203876"} +{"lr": 9.427413961204031e-07, "step": 462, "loss": 1.2644466161727905, "percent_done": 92.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5533.860373608077, "avg_wps": 4852.028870609693, "eta_in_seconds": 513.2632279014175, "at": "2024-05-26T01:35:53.047738"} +{"lr": 8.940333384913533e-07, "step": 463, "loss": 1.3797340393066406, "percent_done": 92.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13873529434204, "wps": 5514.641063086767, "avg_wps": 4853.288368017841, "eta_in_seconds": 499.62660697829904, "at": "2024-05-26T01:36:04.932824"} +{"lr": 8.465984753835264e-07, "step": 464, "loss": 1.3376905918121338, "percent_done": 92.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13866090774536, "wps": 5526.422311025146, "avg_wps": 4854.562720465085, "eta_in_seconds": 485.9955748545712, "at": "2024-05-26T01:36:16.792582"} +{"lr": 8.004388817514974e-07, "step": 465, "loss": 1.4441041946411133, "percent_done": 93.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5540.984049895522, "avg_wps": 4855.85637033613, "eta_in_seconds": 472.36982008205945, "at": "2024-05-26T01:36:28.621176"} +{"lr": 7.555565767654276e-07, "step": 466, "loss": 1.4485150575637817, "percent_done": 93.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5541.514875667664, "avg_wps": 4857.1460284894865, "eta_in_seconds": 458.75170046986426, "at": "2024-05-26T01:36:40.448714"} +{"lr": 7.119535237227388e-07, "step": 467, "loss": 1.4039851427078247, "percent_done": 93.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1380033493042, "wps": 5530.423009438971, "avg_wps": 4858.412551034939, "eta_in_seconds": 445.1429303876848, "at": "2024-05-26T01:36:52.299817"} +{"lr": 6.696316299622224e-07, "step": 468, "loss": 1.4579898118972778, "percent_done": 93.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817262649536, "wps": 5528.233421619218, "avg_wps": 4859.670703555737, "eta_in_seconds": 431.54199696402264, "at": "2024-05-26T01:37:04.155686"} +{"lr": 6.285927467806198e-07, "step": 469, "loss": 1.468167781829834, "percent_done": 93.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.141366481781006, "wps": 5534.032838638812, "avg_wps": 4860.933688865113, "eta_in_seconds": 417.9476886619128, "at": "2024-05-26T01:37:15.999114"} +{"lr": 5.888386693516242e-07, "step": 470, "loss": 1.7039626836776733, "percent_done": 94.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5533.433490906272, "avg_wps": 4862.190967746711, "eta_in_seconds": 404.3609173399337, "at": "2024-05-26T01:37:27.867758"} +{"lr": 5.503711366473705e-07, "step": 471, "loss": 1.2690417766571045, "percent_done": 94.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13718271255493, "wps": 2803.200888024254, "avg_wps": 4854.6202964176155, "eta_in_seconds": 391.4917921392275, "at": "2024-05-26T01:37:51.248014"} +{"lr": 5.131918313623563e-07, "step": 472, "loss": 1.1867066621780396, "percent_done": 94.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5554.745465491234, "avg_wps": 4855.917000218266, "eta_in_seconds": 377.8911377434003, "at": "2024-05-26T01:38:03.047413"} +{"lr": 4.773023798398375e-07, "step": 473, "loss": 1.2774744033813477, "percent_done": 94.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13819980621338, "wps": 5545.210685093927, "avg_wps": 4857.19346991733, "eta_in_seconds": 364.29926272426553, "at": "2024-05-26T01:38:14.867100"} +{"lr": 4.4270435200069295e-07, "step": 474, "loss": 1.5921688079833984, "percent_done": 94.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5548.378287872638, "avg_wps": 4858.470347732369, "eta_in_seconds": 350.7145002532106, "at": "2024-05-26T01:38:26.680054"} +{"lr": 4.0939926127473865e-07, "step": 475, "loss": 1.4718433618545532, "percent_done": 95.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13961887359619, "wps": 5533.022711914743, "avg_wps": 4859.717646931217, "eta_in_seconds": 337.1389284384878, "at": "2024-05-26T01:38:38.525792"} +{"lr": 3.7738856453453507e-07, "step": 476, "loss": 1.1018459796905518, "percent_done": 95.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1370267868042, "wps": 5536.424503263853, "avg_wps": 4860.965854501864, "eta_in_seconds": 323.5702630051044, "at": "2024-05-26T01:38:50.364255"} +{"lr": 3.4667366203166475e-07, "step": 477, "loss": 1.605708122253418, "percent_done": 95.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1397123336792, "wps": 5531.192991590281, "avg_wps": 4862.200998878406, "eta_in_seconds": 310.0093970503697, "at": "2024-05-26T01:39:02.213912"} +{"lr": 3.172558973354582e-07, "step": 478, "loss": 1.5464510917663574, "percent_done": 95.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13789701461792, "wps": 5523.193933056403, "avg_wps": 4863.4186427379045, "eta_in_seconds": 296.45648584106476, "at": "2024-05-26T01:39:14.080674"} +{"lr": 2.8913655727425123e-07, "step": 479, "loss": 1.4629555940628052, "percent_done": 95.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1370267868042, "wps": 5534.455913700166, "avg_wps": 4864.6500105502755, "eta_in_seconds": 282.9095612254173, "at": "2024-05-26T01:39:25.923283"} +{"lr": 2.623168718790634e-07, "step": 480, "loss": 1.308935523033142, "percent_done": 96.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5533.210829539052, "avg_wps": 4865.874861945717, "eta_in_seconds": 269.3698537647724, "at": "2024-05-26T01:39:37.768538"} +{"lr": 2.3679801432982478e-07, "step": 481, "loss": 1.2836899757385254, "percent_done": 96.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1387357711792, "wps": 5538.883527322008, "avg_wps": 4867.104349124798, "eta_in_seconds": 255.83671741574818, "at": "2024-05-26T01:39:49.601629"} +{"lr": 2.1258110090402713e-07, "step": 482, "loss": 1.5766515731811523, "percent_done": 96.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5526.650426726287, "avg_wps": 4868.309702273784, "eta_in_seconds": 242.3116178186108, "at": "2024-05-26T01:40:01.460946"} +{"lr": 1.896671909279231e-07, "step": 483, "loss": 1.0516997575759888, "percent_done": 96.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.139439582824707, "wps": 5530.952592586363, "avg_wps": 4869.517567317775, "eta_in_seconds": 228.79309594803962, "at": "2024-05-26T01:40:13.311042"} +{"lr": 1.6805728673016362e-07, "step": 484, "loss": 1.6656585931777954, "percent_done": 96.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817262649536, "wps": 5531.944595848905, "avg_wps": 4870.722626175347, "eta_in_seconds": 215.28140287951004, "at": "2024-05-26T01:40:25.159010"} +{"lr": 1.477523335979629e-07, "step": 485, "loss": 1.372025489807129, "percent_done": 97.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5521.838768312022, "avg_wps": 4871.907117821334, "eta_in_seconds": 201.77724579437492, "at": "2024-05-26T01:40:37.028650"} +{"lr": 1.2875321973575205e-07, "step": 486, "loss": 1.479919195175171, "percent_done": 97.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13792896270752, "wps": 5534.706424234692, "avg_wps": 4873.10788058636, "eta_in_seconds": 188.2790249021946, "at": "2024-05-26T01:40:48.870698"} +{"lr": 1.1106077622631656e-07, "step": 487, "loss": 1.4514286518096924, "percent_done": 97.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13841724395752, "wps": 5538.060746146945, "avg_wps": 4874.309639355246, "eta_in_seconds": 174.78741873950685, "at": "2024-05-26T01:41:00.705528"} +{"lr": 9.467577699445256e-08, "step": 488, "loss": 1.652998447418213, "percent_done": 97.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5533.492974264452, "avg_wps": 4875.4998016228965, "eta_in_seconds": 161.3028472974652, "at": "2024-05-26T01:41:12.550138"} +{"lr": 7.959893877311043e-08, "step": 489, "loss": 1.6865766048431396, "percent_done": 97.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13866090774536, "wps": 5527.329329568334, "avg_wps": 4876.67587310956, "eta_in_seconds": 147.82528483696998, "at": "2024-05-26T01:41:24.407965"} +{"lr": 6.58309210720302e-08, "step": 490, "loss": 1.6229629516601562, "percent_done": 98.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.138378620147705, "wps": 5530.420116428623, "avg_wps": 4877.852618073053, "eta_in_seconds": 134.35420282519596, "at": "2024-05-26T01:41:36.259189"} +{"lr": 5.337232614891126e-08, "step": 491, "loss": 1.1492687463760376, "percent_done": 98.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1370267868042, "wps": 5537.087628946555, "avg_wps": 4879.035690602307, "eta_in_seconds": 120.88946205826738, "at": "2024-05-26T01:41:48.096162"} +{"lr": 4.222369898305362e-08, "step": 492, "loss": 1.3562477827072144, "percent_done": 98.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13769817352295, "wps": 5529.093100213343, "avg_wps": 4880.2018837778005, "eta_in_seconds": 107.4316211677179, "at": "2024-05-26T01:41:59.950321"} +{"lr": 3.2385527251530405e-08, "step": 493, "loss": 1.3547463417053223, "percent_done": 98.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.138689517974854, "wps": 5528.314696561733, "avg_wps": 4881.362669363302, "eta_in_seconds": 93.98031473449954, "at": "2024-05-26T01:42:11.806184"} +{"lr": 2.385824130784165e-08, "step": 494, "loss": 1.603198528289795, "percent_done": 98.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1392240524292, "wps": 5534.3604181010805, "avg_wps": 4882.5288400314985, "eta_in_seconds": 80.5353153833011, "at": "2024-05-26T01:42:23.649073"} +{"lr": 1.6642214163099443e-08, "step": 495, "loss": 1.408722162246704, "percent_done": 99.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13817310333252, "wps": 5542.347735327411, "avg_wps": 4883.703399631958, "eta_in_seconds": 67.09662180235892, "at": "2024-05-26T01:42:35.474906"} +{"lr": 1.0737761469707708e-08, "step": 496, "loss": 1.444448471069336, "percent_done": 99.2, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.138458728790283, "wps": 5534.3021417759355, "avg_wps": 4884.861165927321, "eta_in_seconds": 53.66457532682726, "at": "2024-05-26T01:42:47.317871"} +{"lr": 6.145141507556636e-09, "step": 497, "loss": 1.5961229801177979, "percent_done": 99.4, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.1397123336792, "wps": 5531.425731089284, "avg_wps": 4886.010305561376, "eta_in_seconds": 40.23896547582308, "at": "2024-05-26T01:42:59.166964"} +{"lr": 2.864555172718443e-09, "step": 498, "loss": 1.2048214673995972, "percent_done": 99.6, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13988208770752, "wps": 5537.711866112709, "avg_wps": 4887.165210088157, "eta_in_seconds": 26.81963763562551, "at": "2024-05-26T01:43:11.002721"} +{"lr": 8.961459686677561e-10, "step": 499, "loss": 1.4899966716766357, "percent_done": 99.8, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.14134693145752, "wps": 5538.832075409613, "avg_wps": 4888.317777472936, "eta_in_seconds": 13.406657051227853, "at": "2024-05-26T01:43:22.835988"} +{"lr": 2.4e-10, "step": 500, "loss": 1.5752968788146973, "percent_done": 100.0, "peak_allocated_mem": 64.85457944869995, "allocated_mem": 24.13963794708252, "wps": 5520.256994018846, "avg_wps": 4889.437227938565, "eta_in_seconds": 0.0, "at": "2024-05-26T01:43:34.709027"} diff --git a/runseed42/tb/events.out.tfevents.1716681048.scw-tender-archimedes.53068.0.train b/runseed42/tb/events.out.tfevents.1716681048.scw-tender-archimedes.53068.0.train new file mode 100644 index 0000000000000000000000000000000000000000..9ba1aad952f5901a46a0f40fa28a187e4fa66ea7 --- /dev/null +++ b/runseed42/tb/events.out.tfevents.1716681048.scw-tender-archimedes.53068.0.train @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:ee78fe1f6b27475e262d69b29dc3d467315ee9ef8a99abee31b85fbab8b3762f +size 215572 diff --git a/runseed42/tb/events.out.tfevents.1716681050.scw-tender-archimedes.53068.1.eval b/runseed42/tb/events.out.tfevents.1716681050.scw-tender-archimedes.53068.1.eval new file mode 100644 index 0000000000000000000000000000000000000000..43e7785b3a5a1a5f3fb5882fa54785ca5a555a44 --- /dev/null +++ b/runseed42/tb/events.out.tfevents.1716681050.scw-tender-archimedes.53068.1.eval @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:33e611e636c82d4630eef4340e44c96be5c5068f3d808b8d1b9da7c6ec99951f +size 88 diff --git a/runseed42/wandb/debug-internal.log b/runseed42/wandb/debug-internal.log new file mode 120000 index 0000000000000000000000000000000000000000..ac261decba36e65043f494d4743e5acf1222ebc7 --- /dev/null +++ b/runseed42/wandb/debug-internal.log @@ -0,0 +1 @@ +run-20240525_235049-kk8bhidf/logs/debug-internal.log \ No newline at end of file diff --git a/runseed42/wandb/debug.log b/runseed42/wandb/debug.log new file mode 120000 index 0000000000000000000000000000000000000000..3762cc49fedb859134c084c01bfa4c53920588a2 --- /dev/null +++ b/runseed42/wandb/debug.log @@ -0,0 +1 @@ +run-20240525_235049-kk8bhidf/logs/debug.log \ No newline at end of file diff --git a/runseed42/wandb/latest-run b/runseed42/wandb/latest-run new file mode 120000 index 0000000000000000000000000000000000000000..6711dedb424152edd299a4d1f2c9e4a1bfab5d28 --- /dev/null +++ b/runseed42/wandb/latest-run @@ -0,0 +1 @@ +run-20240525_235049-kk8bhidf \ No newline at end of file diff --git a/runseed42/wandb/run-20240525_235049-kk8bhidf/files/conda-environment.yaml b/runseed42/wandb/run-20240525_235049-kk8bhidf/files/conda-environment.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b872d6a32156b541e625a9e137de272c9701a8f3 --- /dev/null +++ b/runseed42/wandb/run-20240525_235049-kk8bhidf/files/conda-environment.yaml @@ -0,0 +1,92 @@ +name: chemistralpy310 +channels: + - defaults +dependencies: + - _libgcc_mutex=0.1=main + - _openmp_mutex=5.1=1_gnu + - bzip2=1.0.8=h5eee18b_6 + - ca-certificates=2024.3.11=h06a4308_0 + - ld_impl_linux-64=2.38=h1181459_1 + - libffi=3.4.4=h6a678d5_1 + - libgcc-ng=11.2.0=h1234567_1 + - libgomp=11.2.0=h1234567_1 + - libstdcxx-ng=11.2.0=h1234567_1 + - libuuid=1.41.5=h5eee18b_0 + - ncurses=6.4=h6a678d5_0 + - openssl=3.0.13=h7f8727e_2 + - pip=24.0=py310h06a4308_0 + - python=3.10.14=h955ad1f_1 + - readline=8.2=h5eee18b_0 + - setuptools=69.5.1=py310h06a4308_0 + - sqlite=3.45.3=h5eee18b_0 + - tk=8.6.14=h39e8969_0 + - tzdata=2024a=h04d1e81_0 + - wheel=0.43.0=py310h06a4308_0 + - xz=5.4.6=h5eee18b_1 + - zlib=1.2.13=h5eee18b_1 + - pip: + - absl-py==2.1.0 + - annotated-types==0.7.0 + - attrs==23.2.0 + - certifi==2024.2.2 + - charset-normalizer==3.3.2 + - click==8.1.7 + - docker-pycreds==0.4.0 + - docstring-parser==0.16 + - filelock==3.14.0 + - fire==0.6.0 + - fsspec==2024.5.0 + - gitdb==4.0.11 + - gitpython==3.1.43 + - grpcio==1.64.0 + - idna==3.7 + - jinja2==3.1.4 + - jsonschema==4.21.1 + - jsonschema-specifications==2023.12.1 + - markdown==3.6 + - markupsafe==2.1.5 + - mistral-common==1.1.0 + - mpmath==1.3.0 + - networkx==3.3 + - numpy==1.26.4 + - nvidia-cublas-cu12==12.1.3.1 + - nvidia-cuda-cupti-cu12==12.1.105 + - nvidia-cuda-nvrtc-cu12==12.1.105 + - nvidia-cuda-runtime-cu12==12.1.105 + - nvidia-cudnn-cu12==8.9.2.26 + - nvidia-cufft-cu12==11.0.2.54 + - nvidia-curand-cu12==10.3.2.106 + - nvidia-cusolver-cu12==11.4.5.107 + - nvidia-cusparse-cu12==12.1.0.106 + - nvidia-nccl-cu12==2.19.3 + - nvidia-nvjitlink-cu12==12.5.40 + - nvidia-nvtx-cu12==12.1.105 + - platformdirs==4.2.2 + - protobuf==4.25.3 + - psutil==5.9.8 + - pydantic==2.6.1 + - pydantic-core==2.16.2 + - pyyaml==6.0.1 + - referencing==0.35.1 + - requests==2.32.2 + - rpds-py==0.18.1 + - safetensors==0.4.3 + - sentencepiece==0.1.99 + - sentry-sdk==2.3.1 + - setproctitle==1.3.3 + - simple-parsing==0.1.5 + - six==1.16.0 + - smmap==5.0.1 + - sympy==1.12 + - tensorboard==2.16.2 + - tensorboard-data-server==0.7.2 + - termcolor==2.4.0 + - torch==2.2.0 + - tqdm==4.66.4 + - triton==2.2.0 + - typing-extensions==4.12.0 + - urllib3==2.2.1 + - wandb==0.17.0 + - werkzeug==3.0.3 + - xformers==0.0.24 +prefix: /root/miniconda/envs/chemistralpy310 diff --git a/runseed42/wandb/run-20240525_235049-kk8bhidf/files/config.yaml b/runseed42/wandb/run-20240525_235049-kk8bhidf/files/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..1731bd254c3b9cf5d8b1d018ae168936010349de --- /dev/null +++ b/runseed42/wandb/run-20240525_235049-kk8bhidf/files/config.yaml @@ -0,0 +1,115 @@ +wandb_version: 1 + +data: + desc: null + value: + data: '' + shuffle: false + instruct_data: /root/data/mol_instructions_train.jsonl + eval_instruct_data: '' + instruct: + shuffle: true + dynamic_chunk_fn_call: true +model_id_or_path: + desc: null + value: /root/mistral_models/7B-v0.3 +run_dir: + desc: null + value: /root/mistral-finetune/runseed42 +optim: + desc: null + value: + lr: 6.0e-05 + weight_decay: 0.1 + pct_start: 0.05 +seed: + desc: null + value: 42 +num_microbatches: + desc: null + value: 1 +seq_len: + desc: null + value: 32768 +batch_size: + desc: null + value: 2 +max_norm: + desc: null + value: 1.0 +max_steps: + desc: null + value: 500 +log_freq: + desc: null + value: 1 +ckpt_freq: + desc: null + value: 100 +ckpt_only_lora: + desc: null + value: false +no_ckpt: + desc: null + value: false +num_ckpt_keep: + desc: null + value: 3 +eval_freq: + desc: null + value: 100 +no_eval: + desc: null + value: true +checkpoint: + desc: null + value: true +world_size: + desc: null + value: 1 +wandb: + desc: null + value: + project: CHEMISTral7b-ft + offline: false + key: aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df + run_name: runseed42 +mlflow: + desc: null + value: + tracking_uri: null + experiment_name: null +lora: + desc: null + value: + enable: true + rank: 64 + dropout: 0.0 + scaling: 2.0 +_wandb: + desc: null + value: + python_version: 3.10.14 + cli_version: 0.17.0 + framework: torch + is_jupyter_run: false + is_kaggle_kernel: false + start_time: 1716681049 + t: + 1: + - 1 + - 55 + 2: + - 1 + - 55 + 3: + - 2 + - 13 + - 16 + - 23 + - 61 + 4: 3.10.14 + 5: 0.17.0 + 8: + - 5 + 13: linux-x86_64 diff --git a/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log b/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log new file mode 100644 index 0000000000000000000000000000000000000000..7fa5693fa676f1b1b5237b54033c5a9f423fdb9b --- /dev/null +++ b/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log @@ -0,0 +1,537 @@ + +wandb: WARNING Calling wandb.login() after wandb.init() has no effect. +2024-05-25 23:50:50 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Reloading model from /root/mistral_models/7B-v0.3/consolidated.safetensors ... +2024-05-25 23:50:50 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Converting model to dtype torch.bfloat16 ... +2024-05-25 23:50:50 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Loaded model on cpu! +2024-05-25 23:50:50 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Initializing lora layers ... +2024-05-25 23:50:51 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Finished initialization! +2024-05-25 23:50:51 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Sharding model over 1 GPUs ... +2024-05-25 23:50:52 (UTC) - 0:00:06 - finetune.wrapped_model - INFO - Model sharded! +2024-05-25 23:50:52 (UTC) - 0:00:06 - finetune.wrapped_model - INFO - 167,772,160 out of 7,415,795,712 parameter are finetuned (2.26%). +2024-05-25 23:50:52 (UTC) - 0:00:06 - dataset - INFO - Loading /root/data/mol_instructions_train.jsonl ... +2024-05-26 00:03:09 (UTC) - 0:12:22 - dataset - INFO - /root/data/mol_instructions_train.jsonl loaded and tokenized. +2024-05-26 00:03:09 (UTC) - 0:12:23 - dataset - INFO - Shuffling /root/data/mol_instructions_train.jsonl ... +2024-05-26 00:03:21 (UTC) - 0:12:35 - train - INFO - step: 000001 - done (%): 0.2 - loss: 2.090 - lr: 2.4e-06 - peak_alloc_mem (GB): 63.6 - alloc_mem (GB): 24.1 - words_per_second: 87.6 - avg_words_per_second: 87.6 - ETA: >2024-05-30 07:48:37 +2024-05-26 00:03:32 (UTC) - 0:12:46 - train - INFO - step: 000002 - done (%): 0.4 - loss: 2.525 - lr: 2.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5626.7 - avg_words_per_second: 172.4 - ETA: >2024-05-28 04:38:16 +2024-05-26 00:03:44 (UTC) - 0:12:58 - train - INFO - step: 000003 - done (%): 0.6 - loss: 2.150 - lr: 3.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5601.0 - avg_words_per_second: 254.7 - ETA: >2024-05-27 11:34:58 +2024-05-26 00:03:56 (UTC) - 0:13:10 - train - INFO - step: 000004 - done (%): 0.8 - loss: 2.035 - lr: 4.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.6 - avg_words_per_second: 334.5 - ETA: >2024-05-27 03:03:39 +2024-05-26 00:04:08 (UTC) - 0:13:22 - train - INFO - step: 000005 - done (%): 1.0 - loss: 2.400 - lr: 6.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5562.4 - avg_words_per_second: 411.9 - ETA: >2024-05-26 21:56:44 +2024-05-26 00:04:20 (UTC) - 0:13:33 - train - INFO - step: 000006 - done (%): 1.2 - loss: 2.155 - lr: 8.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5558.3 - avg_words_per_second: 487.1 - ETA: >2024-05-26 18:32:08 +2024-05-26 00:04:31 (UTC) - 0:13:45 - train - INFO - step: 000007 - done (%): 1.4 - loss: 2.195 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.6 - avg_words_per_second: 560.0 - ETA: >2024-05-26 16:06:02 +2024-05-26 00:04:43 (UTC) - 0:13:57 - train - INFO - step: 000008 - done (%): 1.6 - loss: 2.157 - lr: 1.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5545.7 - avg_words_per_second: 631.0 - ETA: >2024-05-26 14:16:27 +2024-05-26 00:04:55 (UTC) - 0:14:09 - train - INFO - step: 000009 - done (%): 1.8 - loss: 1.996 - lr: 1.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5545.3 - avg_words_per_second: 699.9 - ETA: >2024-05-26 12:51:13 +2024-05-26 00:05:07 (UTC) - 0:14:21 - train - INFO - step: 000010 - done (%): 2.0 - loss: 2.043 - lr: 2.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.9 - avg_words_per_second: 766.9 - ETA: >2024-05-26 11:43:03 +2024-05-26 00:05:19 (UTC) - 0:14:32 - train - INFO - step: 000011 - done (%): 2.2 - loss: 2.070 - lr: 2.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.5 - avg_words_per_second: 832.0 - ETA: >2024-05-26 10:47:16 +2024-05-26 00:05:31 (UTC) - 0:14:44 - train - INFO - step: 000012 - done (%): 2.4 - loss: 2.052 - lr: 2.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.7 - avg_words_per_second: 895.4 - ETA: >2024-05-26 10:00:47 +2024-05-26 00:05:42 (UTC) - 0:14:56 - train - INFO - step: 000013 - done (%): 2.6 - loss: 1.819 - lr: 3.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.2 - avg_words_per_second: 957.1 - ETA: >2024-05-26 09:21:28 +2024-05-26 00:05:54 (UTC) - 0:15:08 - train - INFO - step: 000014 - done (%): 2.8 - loss: 1.946 - lr: 3.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.4 - avg_words_per_second: 1017.3 - ETA: >2024-05-26 08:47:44 +2024-05-26 00:06:06 (UTC) - 0:15:20 - train - INFO - step: 000015 - done (%): 3.0 - loss: 1.783 - lr: 3.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.3 - avg_words_per_second: 1075.8 - ETA: >2024-05-26 08:18:31 +2024-05-26 00:06:18 (UTC) - 0:15:32 - train - INFO - step: 000016 - done (%): 3.2 - loss: 2.223 - lr: 4.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.7 - avg_words_per_second: 1132.9 - ETA: >2024-05-26 07:52:57 +2024-05-26 00:06:30 (UTC) - 0:15:43 - train - INFO - step: 000017 - done (%): 3.4 - loss: 1.454 - lr: 4.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.5 - avg_words_per_second: 1188.5 - ETA: >2024-05-26 07:30:23 +2024-05-26 00:06:41 (UTC) - 0:15:55 - train - INFO - step: 000018 - done (%): 3.6 - loss: 1.598 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.7 - avg_words_per_second: 1242.7 - ETA: >2024-05-26 07:10:20 +2024-05-26 00:06:53 (UTC) - 0:16:07 - train - INFO - step: 000019 - done (%): 3.8 - loss: 1.439 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.4 - avg_words_per_second: 1295.6 - ETA: >2024-05-26 06:52:24 +2024-05-26 00:07:05 (UTC) - 0:16:19 - train - INFO - step: 000020 - done (%): 4.0 - loss: 2.101 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.6 - avg_words_per_second: 1347.2 - ETA: >2024-05-26 06:36:15 +2024-05-26 00:07:17 (UTC) - 0:16:31 - train - INFO - step: 000021 - done (%): 4.2 - loss: 1.872 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.5 - avg_words_per_second: 1397.6 - ETA: >2024-05-26 06:21:39 +2024-05-26 00:07:29 (UTC) - 0:16:43 - train - INFO - step: 000022 - done (%): 4.4 - loss: 1.591 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.1 - avg_words_per_second: 1446.7 - ETA: >2024-05-26 06:08:22 +2024-05-26 00:07:41 (UTC) - 0:16:54 - train - INFO - step: 000023 - done (%): 4.6 - loss: 1.609 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5548.0 - avg_words_per_second: 1494.8 - ETA: >2024-05-26 05:56:14 +2024-05-26 00:07:53 (UTC) - 0:17:06 - train - INFO - step: 000024 - done (%): 4.8 - loss: 1.945 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.5 - avg_words_per_second: 1541.7 - ETA: >2024-05-26 05:45:07 +2024-05-26 00:08:04 (UTC) - 0:17:18 - train - INFO - step: 000025 - done (%): 5.0 - loss: 1.901 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.0 - avg_words_per_second: 1587.5 - ETA: >2024-05-26 05:34:54 +2024-05-26 00:08:16 (UTC) - 0:17:30 - train - INFO - step: 000026 - done (%): 5.2 - loss: 2.050 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.3 - avg_words_per_second: 1632.3 - ETA: >2024-05-26 05:25:27 +2024-05-26 00:08:28 (UTC) - 0:17:42 - train - INFO - step: 000027 - done (%): 5.4 - loss: 1.350 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.2 - avg_words_per_second: 1676.0 - ETA: >2024-05-26 05:16:43 +2024-05-26 00:08:40 (UTC) - 0:17:54 - train - INFO - step: 000028 - done (%): 5.6 - loss: 1.784 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.0 - avg_words_per_second: 1718.8 - ETA: >2024-05-26 05:08:36 +2024-05-26 00:08:52 (UTC) - 0:18:06 - train - INFO - step: 000029 - done (%): 5.8 - loss: 1.621 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.5 - avg_words_per_second: 1760.6 - ETA: >2024-05-26 05:01:04 +2024-05-26 00:09:04 (UTC) - 0:18:17 - train - INFO - step: 000030 - done (%): 6.0 - loss: 1.400 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.8 - avg_words_per_second: 1801.6 - ETA: >2024-05-26 04:54:00 +2024-05-26 00:09:15 (UTC) - 0:18:29 - train - INFO - step: 000031 - done (%): 6.2 - loss: 1.431 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5547.8 - avg_words_per_second: 1841.7 - ETA: >2024-05-26 04:47:24 +2024-05-26 00:09:27 (UTC) - 0:18:41 - train - INFO - step: 000032 - done (%): 6.4 - loss: 1.534 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5519.6 - avg_words_per_second: 1880.9 - ETA: >2024-05-26 04:41:14 +2024-05-26 00:09:39 (UTC) - 0:18:53 - train - INFO - step: 000033 - done (%): 6.6 - loss: 1.723 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.1 - avg_words_per_second: 1919.3 - ETA: >2024-05-26 04:35:25 +2024-05-26 00:09:51 (UTC) - 0:19:05 - train - INFO - step: 000034 - done (%): 6.8 - loss: 1.715 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.0 - avg_words_per_second: 1956.9 - ETA: >2024-05-26 04:29:57 +2024-05-26 00:10:03 (UTC) - 0:19:17 - train - INFO - step: 000035 - done (%): 7.0 - loss: 1.494 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.6 - avg_words_per_second: 1993.7 - ETA: >2024-05-26 04:24:48 +2024-05-26 00:10:15 (UTC) - 0:19:28 - train - INFO - step: 000036 - done (%): 7.2 - loss: 1.710 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.4 - avg_words_per_second: 2029.8 - ETA: >2024-05-26 04:19:56 +2024-05-26 00:10:26 (UTC) - 0:19:40 - train - INFO - step: 000037 - done (%): 7.4 - loss: 1.554 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.5 - avg_words_per_second: 2065.1 - ETA: >2024-05-26 04:15:20 +2024-05-26 00:10:38 (UTC) - 0:19:52 - train - INFO - step: 000038 - done (%): 7.6 - loss: 1.769 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.5 - avg_words_per_second: 2099.8 - ETA: >2024-05-26 04:10:58 +2024-05-26 00:10:50 (UTC) - 0:20:04 - train - INFO - step: 000039 - done (%): 7.8 - loss: 1.611 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.0 - avg_words_per_second: 2133.7 - ETA: >2024-05-26 04:06:50 +2024-05-26 00:11:02 (UTC) - 0:20:16 - train - INFO - step: 000040 - done (%): 8.0 - loss: 1.663 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.1 - avg_words_per_second: 2167.0 - ETA: >2024-05-26 04:02:54 +2024-05-26 00:11:14 (UTC) - 0:20:28 - train - INFO - step: 000041 - done (%): 8.2 - loss: 1.559 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.1 - avg_words_per_second: 2199.6 - ETA: >2024-05-26 03:59:09 +2024-05-26 00:11:26 (UTC) - 0:20:39 - train - INFO - step: 000042 - done (%): 8.4 - loss: 1.639 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.1 - avg_words_per_second: 2231.7 - ETA: >2024-05-26 03:55:35 +2024-05-26 00:11:38 (UTC) - 0:20:51 - train - INFO - step: 000043 - done (%): 8.6 - loss: 1.850 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.2 - avg_words_per_second: 2263.1 - ETA: >2024-05-26 03:52:12 +2024-05-26 00:11:49 (UTC) - 0:21:03 - train - INFO - step: 000044 - done (%): 8.8 - loss: 1.619 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.9 - avg_words_per_second: 2293.9 - ETA: >2024-05-26 03:48:57 +2024-05-26 00:12:01 (UTC) - 0:21:15 - train - INFO - step: 000045 - done (%): 9.0 - loss: 1.700 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5523.2 - avg_words_per_second: 2324.1 - ETA: >2024-05-26 03:45:52 +2024-05-26 00:12:13 (UTC) - 0:21:27 - train - INFO - step: 000046 - done (%): 9.2 - loss: 1.773 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5546.1 - avg_words_per_second: 2353.8 - ETA: >2024-05-26 03:42:53 +2024-05-26 00:12:25 (UTC) - 0:21:39 - train - INFO - step: 000047 - done (%): 9.4 - loss: 1.604 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.0 - avg_words_per_second: 2382.9 - ETA: >2024-05-26 03:40:03 +2024-05-26 00:12:37 (UTC) - 0:21:51 - train - INFO - step: 000048 - done (%): 9.6 - loss: 1.581 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.4 - avg_words_per_second: 2411.6 - ETA: >2024-05-26 03:37:20 +2024-05-26 00:12:49 (UTC) - 0:22:02 - train - INFO - step: 000049 - done (%): 9.8 - loss: 1.434 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5547.8 - avg_words_per_second: 2439.7 - ETA: >2024-05-26 03:34:43 +2024-05-26 00:13:00 (UTC) - 0:22:14 - train - INFO - step: 000050 - done (%): 10.0 - loss: 1.450 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.8 - avg_words_per_second: 2467.3 - ETA: >2024-05-26 03:32:13 +2024-05-26 00:13:12 (UTC) - 0:22:26 - train - INFO - step: 000051 - done (%): 10.2 - loss: 1.510 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.0 - avg_words_per_second: 2494.5 - ETA: >2024-05-26 03:29:49 +2024-05-26 00:13:24 (UTC) - 0:22:38 - train - INFO - step: 000052 - done (%): 10.4 - loss: 1.722 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.6 - avg_words_per_second: 2521.1 - ETA: >2024-05-26 03:27:30 +2024-05-26 00:13:36 (UTC) - 0:22:50 - train - INFO - step: 000053 - done (%): 10.6 - loss: 1.703 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.9 - avg_words_per_second: 2547.3 - ETA: >2024-05-26 03:25:16 +2024-05-26 00:13:48 (UTC) - 0:23:01 - train - INFO - step: 000054 - done (%): 10.8 - loss: 1.792 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.3 - avg_words_per_second: 2573.1 - ETA: >2024-05-26 03:23:07 +2024-05-26 00:14:00 (UTC) - 0:23:13 - train - INFO - step: 000055 - done (%): 11.0 - loss: 1.615 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.2 - avg_words_per_second: 2598.3 - ETA: >2024-05-26 03:21:04 +2024-05-26 00:14:11 (UTC) - 0:23:25 - train - INFO - step: 000056 - done (%): 11.2 - loss: 1.494 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5519.5 - avg_words_per_second: 2623.1 - ETA: >2024-05-26 03:19:04 +2024-05-26 00:14:23 (UTC) - 0:23:37 - train - INFO - step: 000057 - done (%): 11.4 - loss: 1.449 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5551.9 - avg_words_per_second: 2647.6 - ETA: >2024-05-26 03:17:09 +2024-05-26 00:14:35 (UTC) - 0:23:49 - train - INFO - step: 000058 - done (%): 11.6 - loss: 1.831 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.9 - avg_words_per_second: 2671.6 - ETA: >2024-05-26 03:15:17 +2024-05-26 00:14:47 (UTC) - 0:24:01 - train - INFO - step: 000059 - done (%): 11.8 - loss: 1.814 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.6 - avg_words_per_second: 2695.2 - ETA: >2024-05-26 03:13:30 +2024-05-26 00:14:59 (UTC) - 0:24:13 - train - INFO - step: 000060 - done (%): 12.0 - loss: 1.513 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.7 - avg_words_per_second: 2718.5 - ETA: >2024-05-26 03:11:46 +2024-05-26 00:15:11 (UTC) - 0:24:24 - train - INFO - step: 000061 - done (%): 12.2 - loss: 1.517 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.4 - avg_words_per_second: 2741.4 - ETA: >2024-05-26 03:10:05 +2024-05-26 00:15:22 (UTC) - 0:24:36 - train - INFO - step: 000062 - done (%): 12.4 - loss: 1.602 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.1 - avg_words_per_second: 2763.9 - ETA: >2024-05-26 03:08:28 +2024-05-26 00:15:34 (UTC) - 0:24:48 - train - INFO - step: 000063 - done (%): 12.6 - loss: 1.462 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.8 - avg_words_per_second: 2786.0 - ETA: >2024-05-26 03:06:54 +2024-05-26 00:15:46 (UTC) - 0:25:00 - train - INFO - step: 000064 - done (%): 12.8 - loss: 1.792 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.3 - avg_words_per_second: 2807.8 - ETA: >2024-05-26 03:05:23 +2024-05-26 00:15:58 (UTC) - 0:25:12 - train - INFO - step: 000065 - done (%): 13.0 - loss: 1.539 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.5 - avg_words_per_second: 2829.2 - ETA: >2024-05-26 03:03:54 +2024-05-26 00:16:10 (UTC) - 0:25:24 - train - INFO - step: 000066 - done (%): 13.2 - loss: 1.535 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.3 - avg_words_per_second: 2850.3 - ETA: >2024-05-26 03:02:28 +2024-05-26 00:16:22 (UTC) - 0:25:35 - train - INFO - step: 000067 - done (%): 13.4 - loss: 1.552 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5545.1 - avg_words_per_second: 2871.2 - ETA: >2024-05-26 03:01:05 +2024-05-26 00:16:33 (UTC) - 0:25:47 - train - INFO - step: 000068 - done (%): 13.6 - loss: 1.508 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.5 - avg_words_per_second: 2891.7 - ETA: >2024-05-26 02:59:44 +2024-05-26 00:16:45 (UTC) - 0:25:59 - train - INFO - step: 000069 - done (%): 13.8 - loss: 1.681 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.5 - avg_words_per_second: 2911.8 - ETA: >2024-05-26 02:58:26 +2024-05-26 00:16:57 (UTC) - 0:26:11 - train - INFO - step: 000070 - done (%): 14.0 - loss: 2.025 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.9 - avg_words_per_second: 2931.7 - ETA: >2024-05-26 02:57:09 +2024-05-26 00:17:09 (UTC) - 0:26:23 - train - INFO - step: 000071 - done (%): 14.2 - loss: 1.291 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.8 - avg_words_per_second: 2951.2 - ETA: >2024-05-26 02:55:55 +2024-05-26 00:17:21 (UTC) - 0:26:35 - train - INFO - step: 000072 - done (%): 14.4 - loss: 1.697 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.2 - avg_words_per_second: 2970.5 - ETA: >2024-05-26 02:54:43 +2024-05-26 00:17:33 (UTC) - 0:26:46 - train - INFO - step: 000073 - done (%): 14.6 - loss: 1.223 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5514.2 - avg_words_per_second: 2989.4 - ETA: >2024-05-26 02:53:34 +2024-05-26 00:17:45 (UTC) - 0:26:58 - train - INFO - step: 000074 - done (%): 14.8 - loss: 1.571 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.4 - avg_words_per_second: 3008.1 - ETA: >2024-05-26 02:52:26 +2024-05-26 00:17:56 (UTC) - 0:27:10 - train - INFO - step: 000075 - done (%): 15.0 - loss: 1.602 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5545.8 - avg_words_per_second: 3026.6 - ETA: >2024-05-26 02:51:19 +2024-05-26 00:18:08 (UTC) - 0:27:22 - train - INFO - step: 000076 - done (%): 15.2 - loss: 1.981 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.5 - avg_words_per_second: 3044.8 - ETA: >2024-05-26 02:50:14 +2024-05-26 00:18:20 (UTC) - 0:27:34 - train - INFO - step: 000077 - done (%): 15.4 - loss: 1.573 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.2 - avg_words_per_second: 3062.6 - ETA: >2024-05-26 02:49:12 +2024-05-26 00:18:32 (UTC) - 0:27:46 - train - INFO - step: 000078 - done (%): 15.6 - loss: 1.532 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5548.9 - avg_words_per_second: 3080.3 - ETA: >2024-05-26 02:48:10 +2024-05-26 00:18:44 (UTC) - 0:27:57 - train - INFO - step: 000079 - done (%): 15.8 - loss: 1.504 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5547.1 - avg_words_per_second: 3097.8 - ETA: >2024-05-26 02:47:10 +2024-05-26 00:18:55 (UTC) - 0:28:09 - train - INFO - step: 000080 - done (%): 16.0 - loss: 1.537 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5547.1 - avg_words_per_second: 3115.0 - ETA: >2024-05-26 02:46:12 +2024-05-26 00:19:07 (UTC) - 0:28:21 - train - INFO - step: 000081 - done (%): 16.2 - loss: 1.585 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.7 - avg_words_per_second: 3131.9 - ETA: >2024-05-26 02:45:15 +2024-05-26 00:19:19 (UTC) - 0:28:33 - train - INFO - step: 000082 - done (%): 16.4 - loss: 1.595 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.3 - avg_words_per_second: 3148.5 - ETA: >2024-05-26 02:44:20 +2024-05-26 00:19:31 (UTC) - 0:28:45 - train - INFO - step: 000083 - done (%): 16.6 - loss: 1.773 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.2 - avg_words_per_second: 3165.0 - ETA: >2024-05-26 02:43:26 +2024-05-26 00:19:43 (UTC) - 0:28:57 - train - INFO - step: 000084 - done (%): 16.8 - loss: 1.526 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.4 - avg_words_per_second: 3181.2 - ETA: >2024-05-26 02:42:33 +2024-05-26 00:19:55 (UTC) - 0:29:08 - train - INFO - step: 000085 - done (%): 17.0 - loss: 1.583 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5523.8 - avg_words_per_second: 3197.2 - ETA: >2024-05-26 02:41:41 +2024-05-26 00:20:07 (UTC) - 0:29:20 - train - INFO - step: 000086 - done (%): 17.2 - loss: 1.361 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.6 - avg_words_per_second: 3213.0 - ETA: >2024-05-26 02:40:51 +2024-05-26 00:20:18 (UTC) - 0:29:32 - train - INFO - step: 000087 - done (%): 17.4 - loss: 1.485 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.7 - avg_words_per_second: 3228.5 - ETA: >2024-05-26 02:40:02 +2024-05-26 00:20:30 (UTC) - 0:29:44 - train - INFO - step: 000088 - done (%): 17.6 - loss: 1.077 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.3 - avg_words_per_second: 3243.9 - ETA: >2024-05-26 02:39:14 +2024-05-26 00:20:42 (UTC) - 0:29:56 - train - INFO - step: 000089 - done (%): 17.8 - loss: 1.551 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.0 - avg_words_per_second: 3259.0 - ETA: >2024-05-26 02:38:27 +2024-05-26 00:20:54 (UTC) - 0:30:08 - train - INFO - step: 000090 - done (%): 18.0 - loss: 1.760 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.2 - avg_words_per_second: 3273.9 - ETA: >2024-05-26 02:37:41 +2024-05-26 00:21:06 (UTC) - 0:30:20 - train - INFO - step: 000091 - done (%): 18.2 - loss: 1.317 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5503.0 - avg_words_per_second: 3288.6 - ETA: >2024-05-26 02:36:57 +2024-05-26 00:21:18 (UTC) - 0:30:31 - train - INFO - step: 000092 - done (%): 18.4 - loss: 1.203 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.8 - avg_words_per_second: 3303.1 - ETA: >2024-05-26 02:36:13 +2024-05-26 00:21:30 (UTC) - 0:30:43 - train - INFO - step: 000093 - done (%): 18.6 - loss: 1.776 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5513.3 - avg_words_per_second: 3317.4 - ETA: >2024-05-26 02:35:30 +2024-05-26 00:21:41 (UTC) - 0:30:55 - train - INFO - step: 000094 - done (%): 18.8 - loss: 1.640 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5503.5 - avg_words_per_second: 3331.5 - ETA: >2024-05-26 02:34:48 +2024-05-26 00:21:53 (UTC) - 0:31:07 - train - INFO - step: 000095 - done (%): 19.0 - loss: 1.642 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.1 - avg_words_per_second: 3345.5 - ETA: >2024-05-26 02:34:07 +2024-05-26 00:22:05 (UTC) - 0:31:19 - train - INFO - step: 000096 - done (%): 19.2 - loss: 1.535 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5519.3 - avg_words_per_second: 3359.3 - ETA: >2024-05-26 02:33:27 +2024-05-26 00:22:17 (UTC) - 0:31:31 - train - INFO - step: 000097 - done (%): 19.4 - loss: 1.290 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.5 - avg_words_per_second: 3373.0 - ETA: >2024-05-26 02:32:47 +2024-05-26 00:22:29 (UTC) - 0:31:43 - train - INFO - step: 000098 - done (%): 19.6 - loss: 1.615 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5523.6 - avg_words_per_second: 3386.5 - ETA: >2024-05-26 02:32:08 +2024-05-26 00:22:41 (UTC) - 0:31:55 - train - INFO - step: 000099 - done (%): 19.8 - loss: 1.716 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.5 - avg_words_per_second: 3399.8 - ETA: >2024-05-26 02:31:31 +2024-05-26 00:22:53 (UTC) - 0:32:06 - train - INFO - step: 000100 - done (%): 20.0 - loss: 1.480 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.3 - avg_words_per_second: 3413.0 - ETA: >2024-05-26 02:30:53 +2024-05-26 00:22:53 (UTC) - 0:32:06 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runseed42/checkpoints/checkpoint_000100/consolidated using tmp name: tmp.consolidated +2024-05-26 00:23:07 (UTC) - 0:32:21 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runseed42/checkpoints/checkpoint_000100/consolidated for step: 100 +2024-05-26 00:23:07 (UTC) - 0:32:21 - checkpointing - INFO - Done deleting checkpoints +2024-05-26 00:23:07 (UTC) - 0:32:21 - checkpointing - INFO - Done! +2024-05-26 00:23:19 (UTC) - 0:32:33 - train - INFO - step: 000101 - done (%): 20.2 - loss: 1.554 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5597.1 - avg_words_per_second: 3426.2 - ETA: >2024-05-26 02:30:31 +2024-05-26 00:23:31 (UTC) - 0:32:45 - train - INFO - step: 000102 - done (%): 20.4 - loss: 1.171 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5565.9 - avg_words_per_second: 3439.2 - ETA: >2024-05-26 02:29:55 +2024-05-26 00:23:43 (UTC) - 0:32:56 - train - INFO - step: 000103 - done (%): 20.6 - loss: 1.518 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5553.1 - avg_words_per_second: 3451.9 - ETA: >2024-05-26 02:29:20 +2024-05-26 00:23:54 (UTC) - 0:33:08 - train - INFO - step: 000104 - done (%): 20.8 - loss: 1.539 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.5 - avg_words_per_second: 3464.5 - ETA: >2024-05-26 02:28:45 +2024-05-26 00:24:06 (UTC) - 0:33:20 - train - INFO - step: 000105 - done (%): 21.0 - loss: 1.385 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.5 - avg_words_per_second: 3476.9 - ETA: >2024-05-26 02:28:12 +2024-05-26 00:24:18 (UTC) - 0:33:32 - train - INFO - step: 000106 - done (%): 21.2 - loss: 1.746 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.9 - avg_words_per_second: 3489.1 - ETA: >2024-05-26 02:27:39 +2024-05-26 00:24:39 (UTC) - 0:33:53 - train - INFO - step: 000107 - done (%): 21.4 - loss: 1.437 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 3110.4 - avg_words_per_second: 3485.1 - ETA: >2024-05-26 02:27:49 +2024-05-26 00:24:51 (UTC) - 0:34:05 - train - INFO - step: 000108 - done (%): 21.6 - loss: 1.471 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5568.3 - avg_words_per_second: 3497.2 - ETA: >2024-05-26 02:27:17 +2024-05-26 00:25:03 (UTC) - 0:34:17 - train - INFO - step: 000109 - done (%): 21.8 - loss: 1.512 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.4 - avg_words_per_second: 3509.1 - ETA: >2024-05-26 02:26:45 +2024-05-26 00:25:15 (UTC) - 0:34:28 - train - INFO - step: 000110 - done (%): 22.0 - loss: 1.631 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.1 - avg_words_per_second: 3520.9 - ETA: >2024-05-26 02:26:14 +2024-05-26 00:25:26 (UTC) - 0:34:40 - train - INFO - step: 000111 - done (%): 22.2 - loss: 1.117 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.3 - avg_words_per_second: 3532.4 - ETA: >2024-05-26 02:25:43 +2024-05-26 00:25:38 (UTC) - 0:34:52 - train - INFO - step: 000112 - done (%): 22.4 - loss: 1.350 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.1 - avg_words_per_second: 3543.9 - ETA: >2024-05-26 02:25:14 +2024-05-26 00:25:50 (UTC) - 0:35:04 - train - INFO - step: 000113 - done (%): 22.6 - loss: 1.663 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.5 - avg_words_per_second: 3555.2 - ETA: >2024-05-26 02:24:44 +2024-05-26 00:26:02 (UTC) - 0:35:16 - train - INFO - step: 000114 - done (%): 22.8 - loss: 1.090 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.3 - avg_words_per_second: 3566.3 - ETA: >2024-05-26 02:24:15 +2024-05-26 00:26:14 (UTC) - 0:35:28 - train - INFO - step: 000115 - done (%): 23.0 - loss: 1.518 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.6 - avg_words_per_second: 3577.4 - ETA: >2024-05-26 02:23:47 +2024-05-26 00:26:26 (UTC) - 0:35:39 - train - INFO - step: 000116 - done (%): 23.2 - loss: 1.607 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.6 - avg_words_per_second: 3588.3 - ETA: >2024-05-26 02:23:19 +2024-05-26 00:26:38 (UTC) - 0:35:51 - train - INFO - step: 000117 - done (%): 23.4 - loss: 1.586 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.5 - avg_words_per_second: 3599.1 - ETA: >2024-05-26 02:22:51 +2024-05-26 00:26:49 (UTC) - 0:36:03 - train - INFO - step: 000118 - done (%): 23.6 - loss: 1.227 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.2 - avg_words_per_second: 3609.9 - ETA: >2024-05-26 02:22:24 +2024-05-26 00:27:01 (UTC) - 0:36:15 - train - INFO - step: 000119 - done (%): 23.8 - loss: 1.324 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.0 - avg_words_per_second: 3620.4 - ETA: >2024-05-26 02:21:58 +2024-05-26 00:27:13 (UTC) - 0:36:27 - train - INFO - step: 000120 - done (%): 24.0 - loss: 1.312 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.2 - avg_words_per_second: 3630.9 - ETA: >2024-05-26 02:21:32 +2024-05-26 00:27:25 (UTC) - 0:36:39 - train - INFO - step: 000121 - done (%): 24.2 - loss: 1.222 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.7 - avg_words_per_second: 3641.2 - ETA: >2024-05-26 02:21:06 +2024-05-26 00:27:37 (UTC) - 0:36:51 - train - INFO - step: 000122 - done (%): 24.4 - loss: 1.667 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.0 - avg_words_per_second: 3651.5 - ETA: >2024-05-26 02:20:41 +2024-05-26 00:27:49 (UTC) - 0:37:02 - train - INFO - step: 000123 - done (%): 24.6 - loss: 1.595 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.6 - avg_words_per_second: 3661.6 - ETA: >2024-05-26 02:20:16 +2024-05-26 00:28:00 (UTC) - 0:37:14 - train - INFO - step: 000124 - done (%): 24.8 - loss: 1.690 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.7 - avg_words_per_second: 3671.6 - ETA: >2024-05-26 02:19:52 +2024-05-26 00:28:12 (UTC) - 0:37:26 - train - INFO - step: 000125 - done (%): 25.0 - loss: 1.671 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.9 - avg_words_per_second: 3681.5 - ETA: >2024-05-26 02:19:28 +2024-05-26 00:28:24 (UTC) - 0:37:38 - train - INFO - step: 000126 - done (%): 25.2 - loss: 1.536 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.0 - avg_words_per_second: 3691.3 - ETA: >2024-05-26 02:19:04 +2024-05-26 00:28:36 (UTC) - 0:37:50 - train - INFO - step: 000127 - done (%): 25.4 - loss: 1.329 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.9 - avg_words_per_second: 3701.0 - ETA: >2024-05-26 02:18:41 +2024-05-26 00:28:48 (UTC) - 0:38:02 - train - INFO - step: 000128 - done (%): 25.6 - loss: 1.250 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.6 - avg_words_per_second: 3710.6 - ETA: >2024-05-26 02:18:18 +2024-05-26 00:29:00 (UTC) - 0:38:13 - train - INFO - step: 000129 - done (%): 25.8 - loss: 1.600 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.3 - avg_words_per_second: 3720.1 - ETA: >2024-05-26 02:17:56 +2024-05-26 00:29:12 (UTC) - 0:38:25 - train - INFO - step: 000130 - done (%): 26.0 - loss: 1.266 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.5 - avg_words_per_second: 3729.4 - ETA: >2024-05-26 02:17:33 +2024-05-26 00:29:23 (UTC) - 0:38:37 - train - INFO - step: 000131 - done (%): 26.2 - loss: 1.473 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.3 - avg_words_per_second: 3738.7 - ETA: >2024-05-26 02:17:12 +2024-05-26 00:29:35 (UTC) - 0:38:49 - train - INFO - step: 000132 - done (%): 26.4 - loss: 1.427 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.7 - avg_words_per_second: 3747.9 - ETA: >2024-05-26 02:16:50 +2024-05-26 00:29:47 (UTC) - 0:39:01 - train - INFO - step: 000133 - done (%): 26.6 - loss: 1.402 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.3 - avg_words_per_second: 3757.0 - ETA: >2024-05-26 02:16:29 +2024-05-26 00:29:59 (UTC) - 0:39:13 - train - INFO - step: 000134 - done (%): 26.8 - loss: 1.696 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.5 - avg_words_per_second: 3766.1 - ETA: >2024-05-26 02:16:08 +2024-05-26 00:30:11 (UTC) - 0:39:25 - train - INFO - step: 000135 - done (%): 27.0 - loss: 1.227 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.3 - avg_words_per_second: 3775.0 - ETA: >2024-05-26 02:15:47 +2024-05-26 00:30:23 (UTC) - 0:39:36 - train - INFO - step: 000136 - done (%): 27.2 - loss: 1.327 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5519.3 - avg_words_per_second: 3783.8 - ETA: >2024-05-26 02:15:27 +2024-05-26 00:30:35 (UTC) - 0:39:48 - train - INFO - step: 000137 - done (%): 27.4 - loss: 1.671 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.0 - avg_words_per_second: 3792.6 - ETA: >2024-05-26 02:15:07 +2024-05-26 00:30:46 (UTC) - 0:40:00 - train - INFO - step: 000138 - done (%): 27.6 - loss: 1.296 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.9 - avg_words_per_second: 3801.2 - ETA: >2024-05-26 02:14:47 +2024-05-26 00:30:58 (UTC) - 0:40:12 - train - INFO - step: 000139 - done (%): 27.8 - loss: 1.329 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5518.8 - avg_words_per_second: 3809.8 - ETA: >2024-05-26 02:14:28 +2024-05-26 00:31:10 (UTC) - 0:40:24 - train - INFO - step: 000140 - done (%): 28.0 - loss: 1.493 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.1 - avg_words_per_second: 3818.3 - ETA: >2024-05-26 02:14:09 +2024-05-26 00:31:22 (UTC) - 0:40:36 - train - INFO - step: 000141 - done (%): 28.2 - loss: 1.597 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.4 - avg_words_per_second: 3826.7 - ETA: >2024-05-26 02:13:50 +2024-05-26 00:31:34 (UTC) - 0:40:48 - train - INFO - step: 000142 - done (%): 28.4 - loss: 1.711 - lr: 5.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.3 - avg_words_per_second: 3835.0 - ETA: >2024-05-26 02:13:32 +2024-05-26 00:31:46 (UTC) - 0:40:59 - train - INFO - step: 000143 - done (%): 28.6 - loss: 1.869 - lr: 5.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.1 - avg_words_per_second: 3843.2 - ETA: >2024-05-26 02:13:13 +2024-05-26 00:31:57 (UTC) - 0:41:11 - train - INFO - step: 000144 - done (%): 28.8 - loss: 1.810 - lr: 5.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.8 - avg_words_per_second: 3851.4 - ETA: >2024-05-26 02:12:55 +2024-05-26 00:32:09 (UTC) - 0:41:23 - train - INFO - step: 000145 - done (%): 29.0 - loss: 1.649 - lr: 5.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.3 - avg_words_per_second: 3859.5 - ETA: >2024-05-26 02:12:37 +2024-05-26 00:32:21 (UTC) - 0:41:35 - train - INFO - step: 000146 - done (%): 29.2 - loss: 1.617 - lr: 5.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.6 - avg_words_per_second: 3867.5 - ETA: >2024-05-26 02:12:20 +2024-05-26 00:32:33 (UTC) - 0:41:47 - train - INFO - step: 000147 - done (%): 29.4 - loss: 1.807 - lr: 5.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.7 - avg_words_per_second: 3875.5 - ETA: >2024-05-26 02:12:02 +2024-05-26 00:32:45 (UTC) - 0:41:59 - train - INFO - step: 000148 - done (%): 29.6 - loss: 1.395 - lr: 5.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.7 - avg_words_per_second: 3883.3 - ETA: >2024-05-26 02:11:45 +2024-05-26 00:32:57 (UTC) - 0:42:10 - train - INFO - step: 000149 - done (%): 29.8 - loss: 1.686 - lr: 5.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.5 - avg_words_per_second: 3891.1 - ETA: >2024-05-26 02:11:28 +2024-05-26 00:33:09 (UTC) - 0:42:22 - train - INFO - step: 000150 - done (%): 30.0 - loss: 1.343 - lr: 5.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.4 - avg_words_per_second: 3898.8 - ETA: >2024-05-26 02:11:12 +2024-05-26 00:33:20 (UTC) - 0:42:34 - train - INFO - step: 000151 - done (%): 30.2 - loss: 1.193 - lr: 5.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.7 - avg_words_per_second: 3906.5 - ETA: >2024-05-26 02:10:55 +2024-05-26 00:33:32 (UTC) - 0:42:46 - train - INFO - step: 000152 - done (%): 30.4 - loss: 1.519 - lr: 5.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.0 - avg_words_per_second: 3914.0 - ETA: >2024-05-26 02:10:39 +2024-05-26 00:33:44 (UTC) - 0:42:58 - train - INFO - step: 000153 - done (%): 30.6 - loss: 1.699 - lr: 5.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.0 - avg_words_per_second: 3921.5 - ETA: >2024-05-26 02:10:23 +2024-05-26 00:33:56 (UTC) - 0:43:10 - train - INFO - step: 000154 - done (%): 30.8 - loss: 1.458 - lr: 5.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.6 - avg_words_per_second: 3929.0 - ETA: >2024-05-26 02:10:07 +2024-05-26 00:34:08 (UTC) - 0:43:21 - train - INFO - step: 000155 - done (%): 31.0 - loss: 1.562 - lr: 5.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5546.4 - avg_words_per_second: 3936.4 - ETA: >2024-05-26 02:09:52 +2024-05-26 00:34:20 (UTC) - 0:43:33 - train - INFO - step: 000156 - done (%): 31.2 - loss: 1.637 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.9 - avg_words_per_second: 3943.7 - ETA: >2024-05-26 02:09:36 +2024-05-26 00:34:31 (UTC) - 0:43:45 - train - INFO - step: 000157 - done (%): 31.4 - loss: 1.838 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.4 - avg_words_per_second: 3951.0 - ETA: >2024-05-26 02:09:21 +2024-05-26 00:34:43 (UTC) - 0:43:57 - train - INFO - step: 000158 - done (%): 31.6 - loss: 1.625 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.5 - avg_words_per_second: 3958.1 - ETA: >2024-05-26 02:09:06 +2024-05-26 00:34:55 (UTC) - 0:44:09 - train - INFO - step: 000159 - done (%): 31.8 - loss: 1.401 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5547.4 - avg_words_per_second: 3965.3 - ETA: >2024-05-26 02:08:51 +2024-05-26 00:35:07 (UTC) - 0:44:21 - train - INFO - step: 000160 - done (%): 32.0 - loss: 1.557 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.1 - avg_words_per_second: 3972.3 - ETA: >2024-05-26 02:08:36 +2024-05-26 00:35:19 (UTC) - 0:44:32 - train - INFO - step: 000161 - done (%): 32.2 - loss: 1.336 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5545.6 - avg_words_per_second: 3979.4 - ETA: >2024-05-26 02:08:22 +2024-05-26 00:35:31 (UTC) - 0:44:44 - train - INFO - step: 000162 - done (%): 32.4 - loss: 1.339 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5506.9 - avg_words_per_second: 3986.2 - ETA: >2024-05-26 02:08:08 +2024-05-26 00:35:42 (UTC) - 0:44:56 - train - INFO - step: 000163 - done (%): 32.6 - loss: 1.278 - lr: 4.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.6 - avg_words_per_second: 3993.1 - ETA: >2024-05-26 02:07:53 +2024-05-26 00:35:54 (UTC) - 0:45:08 - train - INFO - step: 000164 - done (%): 32.8 - loss: 1.407 - lr: 4.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.5 - avg_words_per_second: 3999.9 - ETA: >2024-05-26 02:07:39 +2024-05-26 00:36:06 (UTC) - 0:45:20 - train - INFO - step: 000165 - done (%): 33.0 - loss: 1.471 - lr: 4.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.9 - avg_words_per_second: 4006.6 - ETA: >2024-05-26 02:07:26 +2024-05-26 00:36:18 (UTC) - 0:45:32 - train - INFO - step: 000166 - done (%): 33.2 - loss: 1.556 - lr: 4.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.9 - avg_words_per_second: 4013.3 - ETA: >2024-05-26 02:07:12 +2024-05-26 00:36:30 (UTC) - 0:45:44 - train - INFO - step: 000167 - done (%): 33.4 - loss: 1.467 - lr: 4.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.9 - avg_words_per_second: 4019.9 - ETA: >2024-05-26 02:06:59 +2024-05-26 00:36:42 (UTC) - 0:45:55 - train - INFO - step: 000168 - done (%): 33.6 - loss: 1.508 - lr: 4.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5549.7 - avg_words_per_second: 4026.5 - ETA: >2024-05-26 02:06:45 +2024-05-26 00:36:53 (UTC) - 0:46:07 - train - INFO - step: 000169 - done (%): 33.8 - loss: 1.490 - lr: 4.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5523.4 - avg_words_per_second: 4033.0 - ETA: >2024-05-26 02:06:32 +2024-05-26 00:37:05 (UTC) - 0:46:19 - train - INFO - step: 000170 - done (%): 34.0 - loss: 1.482 - lr: 4.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.4 - avg_words_per_second: 4039.5 - ETA: >2024-05-26 02:06:19 +2024-05-26 00:37:17 (UTC) - 0:46:31 - train - INFO - step: 000171 - done (%): 34.2 - loss: 1.640 - lr: 4.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.0 - avg_words_per_second: 4045.8 - ETA: >2024-05-26 02:06:06 +2024-05-26 00:37:29 (UTC) - 0:46:43 - train - INFO - step: 000172 - done (%): 34.4 - loss: 1.674 - lr: 4.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.9 - avg_words_per_second: 4052.2 - ETA: >2024-05-26 02:05:54 +2024-05-26 00:37:41 (UTC) - 0:46:55 - train - INFO - step: 000173 - done (%): 34.6 - loss: 1.266 - lr: 4.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.1 - avg_words_per_second: 4058.4 - ETA: >2024-05-26 02:05:41 +2024-05-26 00:37:53 (UTC) - 0:47:06 - train - INFO - step: 000174 - done (%): 34.8 - loss: 1.093 - lr: 4.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.8 - avg_words_per_second: 4064.7 - ETA: >2024-05-26 02:05:29 +2024-05-26 00:38:04 (UTC) - 0:47:18 - train - INFO - step: 000175 - done (%): 35.0 - loss: 1.337 - lr: 4.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5552.2 - avg_words_per_second: 4070.9 - ETA: >2024-05-26 02:05:17 +2024-05-26 00:38:16 (UTC) - 0:47:30 - train - INFO - step: 000176 - done (%): 35.2 - loss: 1.516 - lr: 4.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.9 - avg_words_per_second: 4077.0 - ETA: >2024-05-26 02:05:04 +2024-05-26 00:38:28 (UTC) - 0:47:42 - train - INFO - step: 000177 - done (%): 35.4 - loss: 1.329 - lr: 4.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.3 - avg_words_per_second: 4083.1 - ETA: >2024-05-26 02:04:52 +2024-05-26 00:38:40 (UTC) - 0:47:54 - train - INFO - step: 000178 - done (%): 35.6 - loss: 1.486 - lr: 4.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.8 - avg_words_per_second: 4089.1 - ETA: >2024-05-26 02:04:41 +2024-05-26 00:38:52 (UTC) - 0:48:06 - train - INFO - step: 000179 - done (%): 35.8 - loss: 1.235 - lr: 4.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.8 - avg_words_per_second: 4095.1 - ETA: >2024-05-26 02:04:29 +2024-05-26 00:39:04 (UTC) - 0:48:17 - train - INFO - step: 000180 - done (%): 36.0 - loss: 1.484 - lr: 4.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.1 - avg_words_per_second: 4101.0 - ETA: >2024-05-26 02:04:17 +2024-05-26 00:39:15 (UTC) - 0:48:29 - train - INFO - step: 000181 - done (%): 36.2 - loss: 1.627 - lr: 4.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.5 - avg_words_per_second: 4106.9 - ETA: >2024-05-26 02:04:06 +2024-05-26 00:39:27 (UTC) - 0:48:41 - train - INFO - step: 000182 - done (%): 36.4 - loss: 1.649 - lr: 4.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.8 - avg_words_per_second: 4112.8 - ETA: >2024-05-26 02:03:55 +2024-05-26 00:39:39 (UTC) - 0:48:53 - train - INFO - step: 000183 - done (%): 36.6 - loss: 1.343 - lr: 4.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.2 - avg_words_per_second: 4118.6 - ETA: >2024-05-26 02:03:43 +2024-05-26 00:39:51 (UTC) - 0:49:05 - train - INFO - step: 000184 - done (%): 36.8 - loss: 1.782 - lr: 4.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.1 - avg_words_per_second: 4124.4 - ETA: >2024-05-26 02:03:32 +2024-05-26 00:40:03 (UTC) - 0:49:17 - train - INFO - step: 000185 - done (%): 37.0 - loss: 1.370 - lr: 4.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.3 - avg_words_per_second: 4130.1 - ETA: >2024-05-26 02:03:21 +2024-05-26 00:40:15 (UTC) - 0:49:28 - train - INFO - step: 000186 - done (%): 37.2 - loss: 1.286 - lr: 4.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.8 - avg_words_per_second: 4135.7 - ETA: >2024-05-26 02:03:10 +2024-05-26 00:40:27 (UTC) - 0:49:40 - train - INFO - step: 000187 - done (%): 37.4 - loss: 1.611 - lr: 4.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.4 - avg_words_per_second: 4141.3 - ETA: >2024-05-26 02:03:00 +2024-05-26 00:40:38 (UTC) - 0:49:52 - train - INFO - step: 000188 - done (%): 37.6 - loss: 1.772 - lr: 4.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.1 - avg_words_per_second: 4146.8 - ETA: >2024-05-26 02:02:49 +2024-05-26 00:40:50 (UTC) - 0:50:04 - train - INFO - step: 000189 - done (%): 37.8 - loss: 1.272 - lr: 4.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.8 - avg_words_per_second: 4152.3 - ETA: >2024-05-26 02:02:39 +2024-05-26 00:41:02 (UTC) - 0:50:16 - train - INFO - step: 000190 - done (%): 38.0 - loss: 1.009 - lr: 4.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5545.1 - avg_words_per_second: 4157.8 - ETA: >2024-05-26 02:02:28 +2024-05-26 00:41:14 (UTC) - 0:50:28 - train - INFO - step: 000191 - done (%): 38.2 - loss: 1.608 - lr: 4.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.1 - avg_words_per_second: 4163.3 - ETA: >2024-05-26 02:02:18 +2024-05-26 00:41:26 (UTC) - 0:50:39 - train - INFO - step: 000192 - done (%): 38.4 - loss: 1.380 - lr: 4.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.1 - avg_words_per_second: 4168.7 - ETA: >2024-05-26 02:02:08 +2024-05-26 00:41:37 (UTC) - 0:50:51 - train - INFO - step: 000193 - done (%): 38.6 - loss: 1.528 - lr: 4.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5548.6 - avg_words_per_second: 4174.1 - ETA: >2024-05-26 02:01:58 +2024-05-26 00:41:49 (UTC) - 0:51:03 - train - INFO - step: 000194 - done (%): 38.8 - loss: 1.829 - lr: 4.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.5 - avg_words_per_second: 4179.4 - ETA: >2024-05-26 02:01:48 +2024-05-26 00:42:01 (UTC) - 0:51:15 - train - INFO - step: 000195 - done (%): 39.0 - loss: 1.123 - lr: 4.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.2 - avg_words_per_second: 4184.6 - ETA: >2024-05-26 02:01:38 +2024-05-26 00:42:13 (UTC) - 0:51:27 - train - INFO - step: 000196 - done (%): 39.2 - loss: 1.356 - lr: 4.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.7 - avg_words_per_second: 4189.8 - ETA: >2024-05-26 02:01:28 +2024-05-26 00:42:25 (UTC) - 0:51:39 - train - INFO - step: 000197 - done (%): 39.4 - loss: 1.651 - lr: 4.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.3 - avg_words_per_second: 4195.0 - ETA: >2024-05-26 02:01:18 +2024-05-26 00:42:37 (UTC) - 0:51:50 - train - INFO - step: 000198 - done (%): 39.6 - loss: 1.075 - lr: 4.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.4 - avg_words_per_second: 4200.2 - ETA: >2024-05-26 02:01:09 +2024-05-26 00:42:49 (UTC) - 0:52:02 - train - INFO - step: 000199 - done (%): 39.8 - loss: 1.475 - lr: 4.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.6 - avg_words_per_second: 4205.2 - ETA: >2024-05-26 02:00:59 +2024-05-26 00:43:00 (UTC) - 0:52:14 - train - INFO - step: 000200 - done (%): 40.0 - loss: 1.526 - lr: 4.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.2 - avg_words_per_second: 4210.3 - ETA: >2024-05-26 02:00:50 +2024-05-26 00:43:00 (UTC) - 0:52:14 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runseed42/checkpoints/checkpoint_000200/consolidated using tmp name: tmp.consolidated +2024-05-26 00:43:15 (UTC) - 0:52:29 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runseed42/checkpoints/checkpoint_000200/consolidated for step: 200 +2024-05-26 00:43:15 (UTC) - 0:52:29 - checkpointing - INFO - Done deleting checkpoints +2024-05-26 00:43:15 (UTC) - 0:52:29 - checkpointing - INFO - Done! +2024-05-26 00:43:27 (UTC) - 0:52:41 - train - INFO - step: 000201 - done (%): 40.2 - loss: 1.479 - lr: 4.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5596.2 - avg_words_per_second: 4215.5 - ETA: >2024-05-26 02:00:55 +2024-05-26 00:43:39 (UTC) - 0:52:52 - train - INFO - step: 000202 - done (%): 40.4 - loss: 1.498 - lr: 4.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5560.4 - avg_words_per_second: 4220.6 - ETA: >2024-05-26 02:00:46 +2024-05-26 00:43:50 (UTC) - 0:53:04 - train - INFO - step: 000203 - done (%): 40.6 - loss: 1.203 - lr: 4.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5556.1 - avg_words_per_second: 4225.6 - ETA: >2024-05-26 02:00:37 +2024-05-26 00:44:02 (UTC) - 0:53:16 - train - INFO - step: 000204 - done (%): 40.8 - loss: 1.898 - lr: 4.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.9 - avg_words_per_second: 4230.5 - ETA: >2024-05-26 02:00:28 +2024-05-26 00:44:14 (UTC) - 0:53:28 - train - INFO - step: 000205 - done (%): 41.0 - loss: 1.568 - lr: 4.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.5 - avg_words_per_second: 4235.3 - ETA: >2024-05-26 02:00:19 +2024-05-26 00:44:26 (UTC) - 0:53:40 - train - INFO - step: 000206 - done (%): 41.2 - loss: 1.195 - lr: 4.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.9 - avg_words_per_second: 4240.2 - ETA: >2024-05-26 02:00:10 +2024-05-26 00:44:38 (UTC) - 0:53:52 - train - INFO - step: 000207 - done (%): 41.4 - loss: 1.417 - lr: 4.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.0 - avg_words_per_second: 4245.0 - ETA: >2024-05-26 02:00:01 +2024-05-26 00:44:50 (UTC) - 0:54:03 - train - INFO - step: 000208 - done (%): 41.6 - loss: 1.491 - lr: 4.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.7 - avg_words_per_second: 4249.7 - ETA: >2024-05-26 01:59:53 +2024-05-26 00:45:02 (UTC) - 0:54:15 - train - INFO - step: 000209 - done (%): 41.8 - loss: 1.668 - lr: 4.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.9 - avg_words_per_second: 4254.5 - ETA: >2024-05-26 01:59:44 +2024-05-26 00:45:13 (UTC) - 0:54:27 - train - INFO - step: 000210 - done (%): 42.0 - loss: 1.931 - lr: 4.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.6 - avg_words_per_second: 4259.2 - ETA: >2024-05-26 01:59:36 +2024-05-26 00:45:25 (UTC) - 0:54:39 - train - INFO - step: 000211 - done (%): 42.2 - loss: 1.269 - lr: 4.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.9 - avg_words_per_second: 4263.8 - ETA: >2024-05-26 01:59:27 +2024-05-26 00:45:37 (UTC) - 0:54:51 - train - INFO - step: 000212 - done (%): 42.4 - loss: 1.519 - lr: 4.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.9 - avg_words_per_second: 4268.4 - ETA: >2024-05-26 01:59:19 +2024-05-26 00:45:49 (UTC) - 0:55:03 - train - INFO - step: 000213 - done (%): 42.6 - loss: 1.251 - lr: 4.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.1 - avg_words_per_second: 4273.0 - ETA: >2024-05-26 01:59:11 +2024-05-26 00:46:01 (UTC) - 0:55:15 - train - INFO - step: 000214 - done (%): 42.8 - loss: 1.433 - lr: 3.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.0 - avg_words_per_second: 4277.6 - ETA: >2024-05-26 01:59:03 +2024-05-26 00:46:13 (UTC) - 0:55:26 - train - INFO - step: 000215 - done (%): 43.0 - loss: 1.478 - lr: 3.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.5 - avg_words_per_second: 4282.1 - ETA: >2024-05-26 01:58:54 +2024-05-26 00:46:24 (UTC) - 0:55:38 - train - INFO - step: 000216 - done (%): 43.2 - loss: 1.644 - lr: 3.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.5 - avg_words_per_second: 4286.6 - ETA: >2024-05-26 01:58:46 +2024-05-26 00:46:36 (UTC) - 0:55:50 - train - INFO - step: 000217 - done (%): 43.4 - loss: 1.446 - lr: 3.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.1 - avg_words_per_second: 4291.0 - ETA: >2024-05-26 01:58:38 +2024-05-26 00:46:48 (UTC) - 0:56:02 - train - INFO - step: 000218 - done (%): 43.6 - loss: 1.675 - lr: 3.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.4 - avg_words_per_second: 4295.4 - ETA: >2024-05-26 01:58:31 +2024-05-26 00:47:00 (UTC) - 0:56:14 - train - INFO - step: 000219 - done (%): 43.8 - loss: 1.320 - lr: 3.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.4 - avg_words_per_second: 4299.8 - ETA: >2024-05-26 01:58:23 +2024-05-26 00:47:12 (UTC) - 0:56:26 - train - INFO - step: 000220 - done (%): 44.0 - loss: 1.685 - lr: 3.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5510.5 - avg_words_per_second: 4304.1 - ETA: >2024-05-26 01:58:15 +2024-05-26 00:47:24 (UTC) - 0:56:37 - train - INFO - step: 000221 - done (%): 44.2 - loss: 1.387 - lr: 3.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.3 - avg_words_per_second: 4308.4 - ETA: >2024-05-26 01:58:08 +2024-05-26 00:47:36 (UTC) - 0:56:49 - train - INFO - step: 000222 - done (%): 44.4 - loss: 1.462 - lr: 3.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5520.5 - avg_words_per_second: 4312.7 - ETA: >2024-05-26 01:58:00 +2024-05-26 00:47:47 (UTC) - 0:57:01 - train - INFO - step: 000223 - done (%): 44.6 - loss: 1.636 - lr: 3.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.6 - avg_words_per_second: 4317.0 - ETA: >2024-05-26 01:57:53 +2024-05-26 00:47:59 (UTC) - 0:57:13 - train - INFO - step: 000224 - done (%): 44.8 - loss: 1.565 - lr: 3.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.8 - avg_words_per_second: 4321.2 - ETA: >2024-05-26 01:57:45 +2024-05-26 00:48:11 (UTC) - 0:57:25 - train - INFO - step: 000225 - done (%): 45.0 - loss: 1.607 - lr: 3.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.0 - avg_words_per_second: 4325.4 - ETA: >2024-05-26 01:57:38 +2024-05-26 00:48:23 (UTC) - 0:57:37 - train - INFO - step: 000226 - done (%): 45.2 - loss: 1.546 - lr: 3.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.5 - avg_words_per_second: 4329.6 - ETA: >2024-05-26 01:57:30 +2024-05-26 00:48:35 (UTC) - 0:57:49 - train - INFO - step: 000227 - done (%): 45.4 - loss: 1.310 - lr: 3.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5512.1 - avg_words_per_second: 4333.7 - ETA: >2024-05-26 01:57:23 +2024-05-26 00:48:58 (UTC) - 0:58:12 - train - INFO - step: 000228 - done (%): 45.6 - loss: 1.626 - lr: 3.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 2808.3 - avg_words_per_second: 4323.4 - ETA: >2024-05-26 01:57:41 +2024-05-26 00:49:10 (UTC) - 0:58:24 - train - INFO - step: 000229 - done (%): 45.8 - loss: 1.503 - lr: 3.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5571.4 - avg_words_per_second: 4327.6 - ETA: >2024-05-26 01:57:34 +2024-05-26 00:49:22 (UTC) - 0:58:36 - train - INFO - step: 000230 - done (%): 46.0 - loss: 1.609 - lr: 3.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.6 - avg_words_per_second: 4331.8 - ETA: >2024-05-26 01:57:27 +2024-05-26 00:49:34 (UTC) - 0:58:47 - train - INFO - step: 000231 - done (%): 46.2 - loss: 1.805 - lr: 3.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.1 - avg_words_per_second: 4335.9 - ETA: >2024-05-26 01:57:20 +2024-05-26 00:49:45 (UTC) - 0:58:59 - train - INFO - step: 000232 - done (%): 46.4 - loss: 1.419 - lr: 3.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.7 - avg_words_per_second: 4339.9 - ETA: >2024-05-26 01:57:12 +2024-05-26 00:49:57 (UTC) - 0:59:11 - train - INFO - step: 000233 - done (%): 46.6 - loss: 1.543 - lr: 3.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.1 - avg_words_per_second: 4343.9 - ETA: >2024-05-26 01:57:05 +2024-05-26 00:50:09 (UTC) - 0:59:23 - train - INFO - step: 000234 - done (%): 46.8 - loss: 1.407 - lr: 3.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.0 - avg_words_per_second: 4347.9 - ETA: >2024-05-26 01:56:59 +2024-05-26 00:50:21 (UTC) - 0:59:35 - train - INFO - step: 000235 - done (%): 47.0 - loss: 1.557 - lr: 3.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.2 - avg_words_per_second: 4351.9 - ETA: >2024-05-26 01:56:52 +2024-05-26 00:50:33 (UTC) - 0:59:47 - train - INFO - step: 000236 - done (%): 47.2 - loss: 1.335 - lr: 3.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.6 - avg_words_per_second: 4355.8 - ETA: >2024-05-26 01:56:45 +2024-05-26 00:50:45 (UTC) - 0:59:58 - train - INFO - step: 000237 - done (%): 47.4 - loss: 1.634 - lr: 3.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.1 - avg_words_per_second: 4359.7 - ETA: >2024-05-26 01:56:38 +2024-05-26 00:50:57 (UTC) - 1:00:10 - train - INFO - step: 000238 - done (%): 47.6 - loss: 1.426 - lr: 3.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.1 - avg_words_per_second: 4363.6 - ETA: >2024-05-26 01:56:31 +2024-05-26 00:51:08 (UTC) - 1:00:22 - train - INFO - step: 000239 - done (%): 47.8 - loss: 1.242 - lr: 3.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.6 - avg_words_per_second: 4367.5 - ETA: >2024-05-26 01:56:25 +2024-05-26 00:51:20 (UTC) - 1:00:34 - train - INFO - step: 000240 - done (%): 48.0 - loss: 1.546 - lr: 3.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.3 - avg_words_per_second: 4371.3 - ETA: >2024-05-26 01:56:18 +2024-05-26 00:51:32 (UTC) - 1:00:46 - train - INFO - step: 000241 - done (%): 48.2 - loss: 1.631 - lr: 3.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.3 - avg_words_per_second: 4375.1 - ETA: >2024-05-26 01:56:12 +2024-05-26 00:51:44 (UTC) - 1:00:58 - train - INFO - step: 000242 - done (%): 48.4 - loss: 1.126 - lr: 3.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.5 - avg_words_per_second: 4378.9 - ETA: >2024-05-26 01:56:05 +2024-05-26 00:51:56 (UTC) - 1:01:10 - train - INFO - step: 000243 - done (%): 48.6 - loss: 1.687 - lr: 3.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5516.1 - avg_words_per_second: 4382.6 - ETA: >2024-05-26 01:55:59 +2024-05-26 00:52:08 (UTC) - 1:01:21 - train - INFO - step: 000244 - done (%): 48.8 - loss: 1.509 - lr: 3.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.9 - avg_words_per_second: 4386.4 - ETA: >2024-05-26 01:55:53 +2024-05-26 00:52:20 (UTC) - 1:01:33 - train - INFO - step: 000245 - done (%): 49.0 - loss: 1.527 - lr: 3.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5511.7 - avg_words_per_second: 4390.0 - ETA: >2024-05-26 01:55:46 +2024-05-26 00:52:31 (UTC) - 1:01:45 - train - INFO - step: 000246 - done (%): 49.2 - loss: 1.344 - lr: 3.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.1 - avg_words_per_second: 4393.7 - ETA: >2024-05-26 01:55:40 +2024-05-26 00:52:43 (UTC) - 1:01:57 - train - INFO - step: 000247 - done (%): 49.4 - loss: 1.640 - lr: 3.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.1 - avg_words_per_second: 4397.4 - ETA: >2024-05-26 01:55:34 +2024-05-26 00:52:55 (UTC) - 1:02:09 - train - INFO - step: 000248 - done (%): 49.6 - loss: 1.726 - lr: 3.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.3 - avg_words_per_second: 4401.0 - ETA: >2024-05-26 01:55:28 +2024-05-26 00:53:07 (UTC) - 1:02:21 - train - INFO - step: 000249 - done (%): 49.8 - loss: 1.706 - lr: 3.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.5 - avg_words_per_second: 4404.6 - ETA: >2024-05-26 01:55:22 +2024-05-26 00:53:19 (UTC) - 1:02:33 - train - INFO - step: 000250 - done (%): 50.0 - loss: 1.656 - lr: 3.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.0 - avg_words_per_second: 4408.2 - ETA: >2024-05-26 01:55:16 +2024-05-26 00:53:31 (UTC) - 1:02:44 - train - INFO - step: 000251 - done (%): 50.2 - loss: 1.181 - lr: 3.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.2 - avg_words_per_second: 4411.8 - ETA: >2024-05-26 01:55:10 +2024-05-26 00:53:43 (UTC) - 1:02:56 - train - INFO - step: 000252 - done (%): 50.4 - loss: 1.295 - lr: 3.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5509.6 - avg_words_per_second: 4415.3 - ETA: >2024-05-26 01:55:04 +2024-05-26 00:53:54 (UTC) - 1:03:08 - train - INFO - step: 000253 - done (%): 50.6 - loss: 1.379 - lr: 3.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.0 - avg_words_per_second: 4418.8 - ETA: >2024-05-26 01:54:58 +2024-05-26 00:54:06 (UTC) - 1:03:20 - train - INFO - step: 000254 - done (%): 50.8 - loss: 1.383 - lr: 3.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.6 - avg_words_per_second: 4422.3 - ETA: >2024-05-26 01:54:52 +2024-05-26 00:54:18 (UTC) - 1:03:32 - train - INFO - step: 000255 - done (%): 51.0 - loss: 1.625 - lr: 3.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.4 - avg_words_per_second: 4425.8 - ETA: >2024-05-26 01:54:46 +2024-05-26 00:54:30 (UTC) - 1:03:44 - train - INFO - step: 000256 - done (%): 51.2 - loss: 1.198 - lr: 3.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.7 - avg_words_per_second: 4429.2 - ETA: >2024-05-26 01:54:40 +2024-05-26 00:54:42 (UTC) - 1:03:56 - train - INFO - step: 000257 - done (%): 51.4 - loss: 1.312 - lr: 3.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5548.0 - avg_words_per_second: 4432.7 - ETA: >2024-05-26 01:54:34 +2024-05-26 00:54:54 (UTC) - 1:04:07 - train - INFO - step: 000258 - done (%): 51.6 - loss: 1.698 - lr: 3.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.7 - avg_words_per_second: 4436.1 - ETA: >2024-05-26 01:54:29 +2024-05-26 00:55:05 (UTC) - 1:04:19 - train - INFO - step: 000259 - done (%): 51.8 - loss: 1.095 - lr: 3.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.8 - avg_words_per_second: 4439.5 - ETA: >2024-05-26 01:54:23 +2024-05-26 00:55:17 (UTC) - 1:04:31 - train - INFO - step: 000260 - done (%): 52.0 - loss: 1.307 - lr: 3.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.0 - avg_words_per_second: 4442.9 - ETA: >2024-05-26 01:54:17 +2024-05-26 00:55:29 (UTC) - 1:04:43 - train - INFO - step: 000261 - done (%): 52.2 - loss: 1.544 - lr: 3.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5523.8 - avg_words_per_second: 4446.2 - ETA: >2024-05-26 01:54:12 +2024-05-26 00:55:41 (UTC) - 1:04:55 - train - INFO - step: 000262 - done (%): 52.4 - loss: 1.575 - lr: 3.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.5 - avg_words_per_second: 4449.6 - ETA: >2024-05-26 01:54:06 +2024-05-26 00:55:53 (UTC) - 1:05:07 - train - INFO - step: 000263 - done (%): 52.6 - loss: 1.180 - lr: 3.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.4 - avg_words_per_second: 4452.9 - ETA: >2024-05-26 01:54:01 +2024-05-26 00:56:05 (UTC) - 1:05:18 - train - INFO - step: 000264 - done (%): 52.8 - loss: 1.450 - lr: 3.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.0 - avg_words_per_second: 4456.2 - ETA: >2024-05-26 01:53:55 +2024-05-26 00:56:16 (UTC) - 1:05:30 - train - INFO - step: 000265 - done (%): 53.0 - loss: 1.286 - lr: 3.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.3 - avg_words_per_second: 4459.5 - ETA: >2024-05-26 01:53:50 +2024-05-26 00:56:28 (UTC) - 1:05:42 - train - INFO - step: 000266 - done (%): 53.2 - loss: 1.514 - lr: 2.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.4 - avg_words_per_second: 4462.8 - ETA: >2024-05-26 01:53:45 +2024-05-26 00:56:40 (UTC) - 1:05:54 - train - INFO - step: 000267 - done (%): 53.4 - loss: 1.623 - lr: 2.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.9 - avg_words_per_second: 4466.0 - ETA: >2024-05-26 01:53:39 +2024-05-26 00:56:52 (UTC) - 1:06:06 - train - INFO - step: 000268 - done (%): 53.6 - loss: 1.184 - lr: 2.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.7 - avg_words_per_second: 4469.2 - ETA: >2024-05-26 01:53:34 +2024-05-26 00:57:04 (UTC) - 1:06:18 - train - INFO - step: 000269 - done (%): 53.8 - loss: 1.745 - lr: 2.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.9 - avg_words_per_second: 4472.4 - ETA: >2024-05-26 01:53:29 +2024-05-26 00:57:16 (UTC) - 1:06:29 - train - INFO - step: 000270 - done (%): 54.0 - loss: 1.623 - lr: 2.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.4 - avg_words_per_second: 4475.6 - ETA: >2024-05-26 01:53:24 +2024-05-26 00:57:28 (UTC) - 1:06:41 - train - INFO - step: 000271 - done (%): 54.2 - loss: 1.190 - lr: 2.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.1 - avg_words_per_second: 4478.8 - ETA: >2024-05-26 01:53:18 +2024-05-26 00:57:39 (UTC) - 1:06:53 - train - INFO - step: 000272 - done (%): 54.4 - loss: 1.421 - lr: 2.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.0 - avg_words_per_second: 4481.9 - ETA: >2024-05-26 01:53:13 +2024-05-26 00:57:51 (UTC) - 1:07:05 - train - INFO - step: 000273 - done (%): 54.6 - loss: 1.005 - lr: 2.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.1 - avg_words_per_second: 4485.1 - ETA: >2024-05-26 01:53:08 +2024-05-26 00:58:03 (UTC) - 1:07:17 - train - INFO - step: 000274 - done (%): 54.8 - loss: 1.202 - lr: 2.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.2 - avg_words_per_second: 4488.2 - ETA: >2024-05-26 01:53:03 +2024-05-26 00:58:15 (UTC) - 1:07:29 - train - INFO - step: 000275 - done (%): 55.0 - loss: 1.233 - lr: 2.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.8 - avg_words_per_second: 4491.3 - ETA: >2024-05-26 01:52:58 +2024-05-26 00:58:27 (UTC) - 1:07:41 - train - INFO - step: 000276 - done (%): 55.2 - loss: 1.532 - lr: 2.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.3 - avg_words_per_second: 4494.3 - ETA: >2024-05-26 01:52:53 +2024-05-26 00:58:39 (UTC) - 1:07:52 - train - INFO - step: 000277 - done (%): 55.4 - loss: 1.179 - lr: 2.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5523.0 - avg_words_per_second: 4497.4 - ETA: >2024-05-26 01:52:48 +2024-05-26 00:58:50 (UTC) - 1:08:04 - train - INFO - step: 000278 - done (%): 55.6 - loss: 1.482 - lr: 2.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.1 - avg_words_per_second: 4500.4 - ETA: >2024-05-26 01:52:43 +2024-05-26 00:59:02 (UTC) - 1:08:16 - train - INFO - step: 000279 - done (%): 55.8 - loss: 1.697 - lr: 2.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.9 - avg_words_per_second: 4503.4 - ETA: >2024-05-26 01:52:38 +2024-05-26 00:59:14 (UTC) - 1:08:28 - train - INFO - step: 000280 - done (%): 56.0 - loss: 1.623 - lr: 2.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5515.0 - avg_words_per_second: 4506.4 - ETA: >2024-05-26 01:52:34 +2024-05-26 00:59:26 (UTC) - 1:08:40 - train - INFO - step: 000281 - done (%): 56.2 - loss: 1.293 - lr: 2.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.2 - avg_words_per_second: 4509.3 - ETA: >2024-05-26 01:52:29 +2024-05-26 00:59:38 (UTC) - 1:08:52 - train - INFO - step: 000282 - done (%): 56.4 - loss: 1.220 - lr: 2.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.9 - avg_words_per_second: 4512.3 - ETA: >2024-05-26 01:52:24 +2024-05-26 00:59:50 (UTC) - 1:09:03 - train - INFO - step: 000283 - done (%): 56.6 - loss: 1.511 - lr: 2.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5552.8 - avg_words_per_second: 4515.3 - ETA: >2024-05-26 01:52:19 +2024-05-26 01:00:02 (UTC) - 1:09:15 - train - INFO - step: 000284 - done (%): 56.8 - loss: 1.674 - lr: 2.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.1 - avg_words_per_second: 4518.2 - ETA: >2024-05-26 01:52:15 +2024-05-26 01:00:13 (UTC) - 1:09:27 - train - INFO - step: 000285 - done (%): 57.0 - loss: 1.445 - lr: 2.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5512.9 - avg_words_per_second: 4521.1 - ETA: >2024-05-26 01:52:10 +2024-05-26 01:00:25 (UTC) - 1:09:39 - train - INFO - step: 000286 - done (%): 57.2 - loss: 1.278 - lr: 2.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.5 - avg_words_per_second: 4524.0 - ETA: >2024-05-26 01:52:05 +2024-05-26 01:00:37 (UTC) - 1:09:51 - train - INFO - step: 000287 - done (%): 57.4 - loss: 1.244 - lr: 2.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.9 - avg_words_per_second: 4526.8 - ETA: >2024-05-26 01:52:01 +2024-05-26 01:00:49 (UTC) - 1:10:03 - train - INFO - step: 000288 - done (%): 57.6 - loss: 1.469 - lr: 2.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.8 - avg_words_per_second: 4529.7 - ETA: >2024-05-26 01:51:56 +2024-05-26 01:01:01 (UTC) - 1:10:15 - train - INFO - step: 000289 - done (%): 57.8 - loss: 1.517 - lr: 2.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.1 - avg_words_per_second: 4532.5 - ETA: >2024-05-26 01:51:52 +2024-05-26 01:01:13 (UTC) - 1:10:26 - train - INFO - step: 000290 - done (%): 58.0 - loss: 1.294 - lr: 2.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.2 - avg_words_per_second: 4535.4 - ETA: >2024-05-26 01:51:47 +2024-05-26 01:01:25 (UTC) - 1:10:38 - train - INFO - step: 000291 - done (%): 58.2 - loss: 1.319 - lr: 2.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.0 - avg_words_per_second: 4538.2 - ETA: >2024-05-26 01:51:43 +2024-05-26 01:01:36 (UTC) - 1:10:50 - train - INFO - step: 000292 - done (%): 58.4 - loss: 1.283 - lr: 2.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.3 - avg_words_per_second: 4540.9 - ETA: >2024-05-26 01:51:38 +2024-05-26 01:01:48 (UTC) - 1:11:02 - train - INFO - step: 000293 - done (%): 58.6 - loss: 1.201 - lr: 2.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5516.1 - avg_words_per_second: 4543.7 - ETA: >2024-05-26 01:51:34 +2024-05-26 01:02:00 (UTC) - 1:11:14 - train - INFO - step: 000294 - done (%): 58.8 - loss: 1.505 - lr: 2.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.1 - avg_words_per_second: 4546.5 - ETA: >2024-05-26 01:51:30 +2024-05-26 01:02:12 (UTC) - 1:11:26 - train - INFO - step: 000295 - done (%): 59.0 - loss: 1.294 - lr: 2.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.5 - avg_words_per_second: 4549.2 - ETA: >2024-05-26 01:51:25 +2024-05-26 01:02:24 (UTC) - 1:11:38 - train - INFO - step: 000296 - done (%): 59.2 - loss: 1.433 - lr: 2.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.6 - avg_words_per_second: 4551.9 - ETA: >2024-05-26 01:51:21 +2024-05-26 01:02:36 (UTC) - 1:11:49 - train - INFO - step: 000297 - done (%): 59.4 - loss: 1.152 - lr: 2.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5548.1 - avg_words_per_second: 4554.7 - ETA: >2024-05-26 01:51:17 +2024-05-26 01:02:47 (UTC) - 1:12:01 - train - INFO - step: 000298 - done (%): 59.6 - loss: 1.601 - lr: 2.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.5 - avg_words_per_second: 4557.4 - ETA: >2024-05-26 01:51:12 +2024-05-26 01:02:59 (UTC) - 1:12:13 - train - INFO - step: 000299 - done (%): 59.8 - loss: 1.257 - lr: 2.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5506.7 - avg_words_per_second: 4560.0 - ETA: >2024-05-26 01:51:08 +2024-05-26 01:03:11 (UTC) - 1:12:25 - train - INFO - step: 000300 - done (%): 60.0 - loss: 1.041 - lr: 2.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.3 - avg_words_per_second: 4562.7 - ETA: >2024-05-26 01:51:04 +2024-05-26 01:03:11 (UTC) - 1:12:25 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runseed42/checkpoints/checkpoint_000300/consolidated using tmp name: tmp.consolidated +2024-05-26 01:03:26 (UTC) - 1:12:40 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runseed42/checkpoints/checkpoint_000300/consolidated for step: 300 +2024-05-26 01:03:26 (UTC) - 1:12:40 - checkpointing - INFO - Done deleting checkpoints +2024-05-26 01:03:26 (UTC) - 1:12:40 - checkpointing - INFO - Done! +2024-05-26 01:03:37 (UTC) - 1:12:51 - train - INFO - step: 000301 - done (%): 60.2 - loss: 1.191 - lr: 2.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5601.1 - avg_words_per_second: 4565.5 - ETA: >2024-05-26 01:51:14 +2024-05-26 01:03:49 (UTC) - 1:13:03 - train - INFO - step: 000302 - done (%): 60.4 - loss: 1.313 - lr: 2.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5560.0 - avg_words_per_second: 4568.2 - ETA: >2024-05-26 01:51:10 +2024-05-26 01:04:01 (UTC) - 1:13:15 - train - INFO - step: 000303 - done (%): 60.6 - loss: 1.327 - lr: 2.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5553.9 - avg_words_per_second: 4570.9 - ETA: >2024-05-26 01:51:06 +2024-05-26 01:04:13 (UTC) - 1:13:27 - train - INFO - step: 000304 - done (%): 60.8 - loss: 1.264 - lr: 2.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.0 - avg_words_per_second: 4573.5 - ETA: >2024-05-26 01:51:01 +2024-05-26 01:04:25 (UTC) - 1:13:39 - train - INFO - step: 000305 - done (%): 61.0 - loss: 1.413 - lr: 2.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.1 - avg_words_per_second: 4576.2 - ETA: >2024-05-26 01:50:57 +2024-05-26 01:04:37 (UTC) - 1:13:50 - train - INFO - step: 000306 - done (%): 61.2 - loss: 1.423 - lr: 2.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5547.7 - avg_words_per_second: 4578.8 - ETA: >2024-05-26 01:50:53 +2024-05-26 01:04:48 (UTC) - 1:14:02 - train - INFO - step: 000307 - done (%): 61.4 - loss: 1.584 - lr: 2.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5521.2 - avg_words_per_second: 4581.3 - ETA: >2024-05-26 01:50:49 +2024-05-26 01:05:00 (UTC) - 1:14:14 - train - INFO - step: 000308 - done (%): 61.6 - loss: 1.246 - lr: 2.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.4 - avg_words_per_second: 4583.9 - ETA: >2024-05-26 01:50:45 +2024-05-26 01:05:12 (UTC) - 1:14:26 - train - INFO - step: 000309 - done (%): 61.8 - loss: 1.516 - lr: 2.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.6 - avg_words_per_second: 4586.4 - ETA: >2024-05-26 01:50:41 +2024-05-26 01:05:24 (UTC) - 1:14:38 - train - INFO - step: 000310 - done (%): 62.0 - loss: 1.587 - lr: 2.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.2 - avg_words_per_second: 4589.0 - ETA: >2024-05-26 01:50:37 +2024-05-26 01:05:36 (UTC) - 1:14:50 - train - INFO - step: 000311 - done (%): 62.2 - loss: 1.362 - lr: 2.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.5 - avg_words_per_second: 4591.5 - ETA: >2024-05-26 01:50:33 +2024-05-26 01:05:48 (UTC) - 1:15:01 - train - INFO - step: 000312 - done (%): 62.4 - loss: 1.684 - lr: 2.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.9 - avg_words_per_second: 4594.0 - ETA: >2024-05-26 01:50:30 +2024-05-26 01:06:00 (UTC) - 1:15:13 - train - INFO - step: 000313 - done (%): 62.6 - loss: 1.049 - lr: 2.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5512.0 - avg_words_per_second: 4596.5 - ETA: >2024-05-26 01:50:26 +2024-05-26 01:06:11 (UTC) - 1:15:25 - train - INFO - step: 000314 - done (%): 62.8 - loss: 1.436 - lr: 2.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.9 - avg_words_per_second: 4598.9 - ETA: >2024-05-26 01:50:22 +2024-05-26 01:06:23 (UTC) - 1:15:37 - train - INFO - step: 000315 - done (%): 63.0 - loss: 1.839 - lr: 2.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.4 - avg_words_per_second: 4601.4 - ETA: >2024-05-26 01:50:18 +2024-05-26 01:06:35 (UTC) - 1:15:49 - train - INFO - step: 000316 - done (%): 63.2 - loss: 1.469 - lr: 2.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.5 - avg_words_per_second: 4603.8 - ETA: >2024-05-26 01:50:14 +2024-05-26 01:06:47 (UTC) - 1:16:01 - train - INFO - step: 000317 - done (%): 63.4 - loss: 1.406 - lr: 1.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5512.3 - avg_words_per_second: 4606.2 - ETA: >2024-05-26 01:50:11 +2024-05-26 01:06:59 (UTC) - 1:16:13 - train - INFO - step: 000318 - done (%): 63.6 - loss: 1.654 - lr: 1.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.7 - avg_words_per_second: 4608.6 - ETA: >2024-05-26 01:50:07 +2024-05-26 01:07:11 (UTC) - 1:16:24 - train - INFO - step: 000319 - done (%): 63.8 - loss: 1.409 - lr: 1.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.4 - avg_words_per_second: 4611.0 - ETA: >2024-05-26 01:50:03 +2024-05-26 01:07:23 (UTC) - 1:16:36 - train - INFO - step: 000320 - done (%): 64.0 - loss: 1.587 - lr: 1.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5523.1 - avg_words_per_second: 4613.4 - ETA: >2024-05-26 01:50:00 +2024-05-26 01:07:34 (UTC) - 1:16:48 - train - INFO - step: 000321 - done (%): 64.2 - loss: 1.452 - lr: 1.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.3 - avg_words_per_second: 4615.8 - ETA: >2024-05-26 01:49:56 +2024-05-26 01:07:46 (UTC) - 1:17:00 - train - INFO - step: 000322 - done (%): 64.4 - loss: 1.523 - lr: 1.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.6 - avg_words_per_second: 4618.2 - ETA: >2024-05-26 01:49:52 +2024-05-26 01:07:58 (UTC) - 1:17:12 - train - INFO - step: 000323 - done (%): 64.6 - loss: 1.391 - lr: 1.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.9 - avg_words_per_second: 4620.5 - ETA: >2024-05-26 01:49:49 +2024-05-26 01:08:10 (UTC) - 1:17:24 - train - INFO - step: 000324 - done (%): 64.8 - loss: 1.356 - lr: 1.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5512.7 - avg_words_per_second: 4622.8 - ETA: >2024-05-26 01:49:45 +2024-05-26 01:08:22 (UTC) - 1:17:36 - train - INFO - step: 000325 - done (%): 65.0 - loss: 1.194 - lr: 1.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5516.6 - avg_words_per_second: 4625.1 - ETA: >2024-05-26 01:49:42 +2024-05-26 01:08:34 (UTC) - 1:17:48 - train - INFO - step: 000326 - done (%): 65.2 - loss: 1.267 - lr: 1.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5518.1 - avg_words_per_second: 4627.4 - ETA: >2024-05-26 01:49:38 +2024-05-26 01:08:46 (UTC) - 1:17:59 - train - INFO - step: 000327 - done (%): 65.4 - loss: 1.486 - lr: 1.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5520.6 - avg_words_per_second: 4629.7 - ETA: >2024-05-26 01:49:35 +2024-05-26 01:08:58 (UTC) - 1:18:11 - train - INFO - step: 000328 - done (%): 65.6 - loss: 1.323 - lr: 1.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5513.1 - avg_words_per_second: 4632.0 - ETA: >2024-05-26 01:49:31 +2024-05-26 01:09:09 (UTC) - 1:18:23 - train - INFO - step: 000329 - done (%): 65.8 - loss: 1.070 - lr: 1.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5520.5 - avg_words_per_second: 4634.2 - ETA: >2024-05-26 01:49:28 +2024-05-26 01:09:21 (UTC) - 1:18:35 - train - INFO - step: 000330 - done (%): 66.0 - loss: 1.277 - lr: 1.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.1 - avg_words_per_second: 4636.5 - ETA: >2024-05-26 01:49:24 +2024-05-26 01:09:33 (UTC) - 1:18:47 - train - INFO - step: 000331 - done (%): 66.2 - loss: 1.302 - lr: 1.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.7 - avg_words_per_second: 4638.8 - ETA: >2024-05-26 01:49:21 +2024-05-26 01:09:45 (UTC) - 1:18:59 - train - INFO - step: 000332 - done (%): 66.4 - loss: 1.268 - lr: 1.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.3 - avg_words_per_second: 4641.0 - ETA: >2024-05-26 01:49:17 +2024-05-26 01:09:57 (UTC) - 1:19:11 - train - INFO - step: 000333 - done (%): 66.6 - loss: 1.077 - lr: 1.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.6 - avg_words_per_second: 4643.3 - ETA: >2024-05-26 01:49:14 +2024-05-26 01:10:09 (UTC) - 1:19:22 - train - INFO - step: 000334 - done (%): 66.8 - loss: 1.010 - lr: 1.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5545.2 - avg_words_per_second: 4645.5 - ETA: >2024-05-26 01:49:10 +2024-05-26 01:10:20 (UTC) - 1:19:34 - train - INFO - step: 000335 - done (%): 67.0 - loss: 1.095 - lr: 1.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.1 - avg_words_per_second: 4647.8 - ETA: >2024-05-26 01:49:07 +2024-05-26 01:10:32 (UTC) - 1:19:46 - train - INFO - step: 000336 - done (%): 67.2 - loss: 1.626 - lr: 1.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.3 - avg_words_per_second: 4650.0 - ETA: >2024-05-26 01:49:04 +2024-05-26 01:10:44 (UTC) - 1:19:58 - train - INFO - step: 000337 - done (%): 67.4 - loss: 1.399 - lr: 1.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.2 - avg_words_per_second: 4652.2 - ETA: >2024-05-26 01:49:00 +2024-05-26 01:10:56 (UTC) - 1:20:10 - train - INFO - step: 000338 - done (%): 67.6 - loss: 1.136 - lr: 1.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.3 - avg_words_per_second: 4654.4 - ETA: >2024-05-26 01:48:57 +2024-05-26 01:11:08 (UTC) - 1:20:22 - train - INFO - step: 000339 - done (%): 67.8 - loss: 1.381 - lr: 1.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5521.3 - avg_words_per_second: 4656.6 - ETA: >2024-05-26 01:48:54 +2024-05-26 01:11:20 (UTC) - 1:20:33 - train - INFO - step: 000340 - done (%): 68.0 - loss: 1.155 - lr: 1.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.7 - avg_words_per_second: 4658.8 - ETA: >2024-05-26 01:48:50 +2024-05-26 01:11:32 (UTC) - 1:20:45 - train - INFO - step: 000341 - done (%): 68.2 - loss: 1.939 - lr: 1.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.8 - avg_words_per_second: 4660.9 - ETA: >2024-05-26 01:48:47 +2024-05-26 01:11:43 (UTC) - 1:20:57 - train - INFO - step: 000342 - done (%): 68.4 - loss: 1.596 - lr: 1.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.4 - avg_words_per_second: 4663.1 - ETA: >2024-05-26 01:48:44 +2024-05-26 01:11:55 (UTC) - 1:21:09 - train - INFO - step: 000343 - done (%): 68.6 - loss: 1.490 - lr: 1.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.6 - avg_words_per_second: 4665.2 - ETA: >2024-05-26 01:48:41 +2024-05-26 01:12:07 (UTC) - 1:21:21 - train - INFO - step: 000344 - done (%): 68.8 - loss: 1.368 - lr: 1.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.0 - avg_words_per_second: 4667.3 - ETA: >2024-05-26 01:48:38 +2024-05-26 01:12:19 (UTC) - 1:21:33 - train - INFO - step: 000345 - done (%): 69.0 - loss: 1.372 - lr: 1.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.9 - avg_words_per_second: 4669.5 - ETA: >2024-05-26 01:48:34 +2024-05-26 01:12:31 (UTC) - 1:21:45 - train - INFO - step: 000346 - done (%): 69.2 - loss: 1.399 - lr: 1.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.3 - avg_words_per_second: 4671.6 - ETA: >2024-05-26 01:48:31 +2024-05-26 01:12:43 (UTC) - 1:21:56 - train - INFO - step: 000347 - done (%): 69.4 - loss: 1.325 - lr: 1.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5546.7 - avg_words_per_second: 4673.7 - ETA: >2024-05-26 01:48:28 +2024-05-26 01:12:54 (UTC) - 1:22:08 - train - INFO - step: 000348 - done (%): 69.6 - loss: 1.492 - lr: 1.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.9 - avg_words_per_second: 4675.8 - ETA: >2024-05-26 01:48:25 +2024-05-26 01:13:18 (UTC) - 1:22:32 - train - INFO - step: 000349 - done (%): 69.8 - loss: 1.603 - lr: 1.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 2799.8 - avg_words_per_second: 4666.8 - ETA: >2024-05-26 01:48:38 +2024-05-26 01:13:30 (UTC) - 1:22:43 - train - INFO - step: 000350 - done (%): 70.0 - loss: 1.372 - lr: 1.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5549.9 - avg_words_per_second: 4669.0 - ETA: >2024-05-26 01:48:35 +2024-05-26 01:13:41 (UTC) - 1:22:55 - train - INFO - step: 000351 - done (%): 70.2 - loss: 1.224 - lr: 1.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5549.7 - avg_words_per_second: 4671.1 - ETA: >2024-05-26 01:48:32 +2024-05-26 01:13:53 (UTC) - 1:23:07 - train - INFO - step: 000352 - done (%): 70.4 - loss: 1.405 - lr: 1.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.1 - avg_words_per_second: 4673.2 - ETA: >2024-05-26 01:48:29 +2024-05-26 01:14:05 (UTC) - 1:23:19 - train - INFO - step: 000353 - done (%): 70.6 - loss: 1.396 - lr: 1.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.5 - avg_words_per_second: 4675.2 - ETA: >2024-05-26 01:48:26 +2024-05-26 01:14:17 (UTC) - 1:23:31 - train - INFO - step: 000354 - done (%): 70.8 - loss: 1.663 - lr: 1.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.3 - avg_words_per_second: 4677.3 - ETA: >2024-05-26 01:48:23 +2024-05-26 01:14:29 (UTC) - 1:23:43 - train - INFO - step: 000355 - done (%): 71.0 - loss: 1.495 - lr: 1.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.4 - avg_words_per_second: 4679.3 - ETA: >2024-05-26 01:48:20 +2024-05-26 01:14:41 (UTC) - 1:23:54 - train - INFO - step: 000356 - done (%): 71.2 - loss: 1.707 - lr: 1.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5521.7 - avg_words_per_second: 4681.3 - ETA: >2024-05-26 01:48:17 +2024-05-26 01:14:52 (UTC) - 1:24:06 - train - INFO - step: 000357 - done (%): 71.4 - loss: 1.180 - lr: 1.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.0 - avg_words_per_second: 4683.3 - ETA: >2024-05-26 01:48:14 +2024-05-26 01:15:04 (UTC) - 1:24:18 - train - INFO - step: 000358 - done (%): 71.6 - loss: 1.324 - lr: 1.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.5 - avg_words_per_second: 4685.4 - ETA: >2024-05-26 01:48:11 +2024-05-26 01:15:16 (UTC) - 1:24:30 - train - INFO - step: 000359 - done (%): 71.8 - loss: 1.286 - lr: 1.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.5 - avg_words_per_second: 4687.4 - ETA: >2024-05-26 01:48:08 +2024-05-26 01:15:28 (UTC) - 1:24:42 - train - INFO - step: 000360 - done (%): 72.0 - loss: 1.044 - lr: 1.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.8 - avg_words_per_second: 4689.3 - ETA: >2024-05-26 01:48:05 +2024-05-26 01:15:40 (UTC) - 1:24:54 - train - INFO - step: 000361 - done (%): 72.2 - loss: 1.564 - lr: 1.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.7 - avg_words_per_second: 4691.3 - ETA: >2024-05-26 01:48:02 +2024-05-26 01:15:52 (UTC) - 1:25:06 - train - INFO - step: 000362 - done (%): 72.4 - loss: 1.362 - lr: 1.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.5 - avg_words_per_second: 4693.3 - ETA: >2024-05-26 01:47:59 +2024-05-26 01:16:04 (UTC) - 1:25:17 - train - INFO - step: 000363 - done (%): 72.6 - loss: 1.225 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.9 - avg_words_per_second: 4695.2 - ETA: >2024-05-26 01:47:56 +2024-05-26 01:16:15 (UTC) - 1:25:29 - train - INFO - step: 000364 - done (%): 72.8 - loss: 1.473 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.1 - avg_words_per_second: 4697.2 - ETA: >2024-05-26 01:47:53 +2024-05-26 01:16:27 (UTC) - 1:25:41 - train - INFO - step: 000365 - done (%): 73.0 - loss: 1.737 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5518.7 - avg_words_per_second: 4699.1 - ETA: >2024-05-26 01:47:50 +2024-05-26 01:16:39 (UTC) - 1:25:53 - train - INFO - step: 000366 - done (%): 73.2 - loss: 1.155 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.0 - avg_words_per_second: 4701.0 - ETA: >2024-05-26 01:47:47 +2024-05-26 01:16:51 (UTC) - 1:26:05 - train - INFO - step: 000367 - done (%): 73.4 - loss: 1.304 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.9 - avg_words_per_second: 4702.9 - ETA: >2024-05-26 01:47:44 +2024-05-26 01:17:03 (UTC) - 1:26:17 - train - INFO - step: 000368 - done (%): 73.6 - loss: 1.201 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.5 - avg_words_per_second: 4704.8 - ETA: >2024-05-26 01:47:42 +2024-05-26 01:17:15 (UTC) - 1:26:29 - train - INFO - step: 000369 - done (%): 73.8 - loss: 1.503 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5507.5 - avg_words_per_second: 4706.7 - ETA: >2024-05-26 01:47:39 +2024-05-26 01:17:27 (UTC) - 1:26:40 - train - INFO - step: 000370 - done (%): 74.0 - loss: 1.333 - lr: 1.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.8 - avg_words_per_second: 4708.6 - ETA: >2024-05-26 01:47:36 +2024-05-26 01:17:39 (UTC) - 1:26:52 - train - INFO - step: 000371 - done (%): 74.2 - loss: 1.342 - lr: 1.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.4 - avg_words_per_second: 4710.5 - ETA: >2024-05-26 01:47:33 +2024-05-26 01:17:50 (UTC) - 1:27:04 - train - INFO - step: 000372 - done (%): 74.4 - loss: 1.367 - lr: 1.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.8 - avg_words_per_second: 4712.3 - ETA: >2024-05-26 01:47:31 +2024-05-26 01:18:02 (UTC) - 1:27:16 - train - INFO - step: 000373 - done (%): 74.6 - loss: 1.552 - lr: 1.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.0 - avg_words_per_second: 4714.2 - ETA: >2024-05-26 01:47:28 +2024-05-26 01:18:14 (UTC) - 1:27:28 - train - INFO - step: 000374 - done (%): 74.8 - loss: 1.362 - lr: 9.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5514.2 - avg_words_per_second: 4716.0 - ETA: >2024-05-26 01:47:25 +2024-05-26 01:18:26 (UTC) - 1:27:40 - train - INFO - step: 000375 - done (%): 75.0 - loss: 1.294 - lr: 9.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.2 - avg_words_per_second: 4717.9 - ETA: >2024-05-26 01:47:22 +2024-05-26 01:18:38 (UTC) - 1:27:52 - train - INFO - step: 000376 - done (%): 75.2 - loss: 1.182 - lr: 9.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.5 - avg_words_per_second: 4719.7 - ETA: >2024-05-26 01:47:20 +2024-05-26 01:18:50 (UTC) - 1:28:03 - train - INFO - step: 000377 - done (%): 75.4 - loss: 1.581 - lr: 9.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.5 - avg_words_per_second: 4721.6 - ETA: >2024-05-26 01:47:17 +2024-05-26 01:19:02 (UTC) - 1:28:15 - train - INFO - step: 000378 - done (%): 75.6 - loss: 1.324 - lr: 9.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5512.0 - avg_words_per_second: 4723.4 - ETA: >2024-05-26 01:47:14 +2024-05-26 01:19:13 (UTC) - 1:28:27 - train - INFO - step: 000379 - done (%): 75.8 - loss: 1.329 - lr: 9.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.4 - avg_words_per_second: 4725.2 - ETA: >2024-05-26 01:47:12 +2024-05-26 01:19:25 (UTC) - 1:28:39 - train - INFO - step: 000380 - done (%): 76.0 - loss: 1.302 - lr: 9.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5520.2 - avg_words_per_second: 4727.0 - ETA: >2024-05-26 01:47:09 +2024-05-26 01:19:37 (UTC) - 1:28:51 - train - INFO - step: 000381 - done (%): 76.2 - loss: 1.172 - lr: 8.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5506.1 - avg_words_per_second: 4728.7 - ETA: >2024-05-26 01:47:06 +2024-05-26 01:19:49 (UTC) - 1:29:03 - train - INFO - step: 000382 - done (%): 76.4 - loss: 1.184 - lr: 8.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.6 - avg_words_per_second: 4730.5 - ETA: >2024-05-26 01:47:04 +2024-05-26 01:20:01 (UTC) - 1:29:15 - train - INFO - step: 000383 - done (%): 76.6 - loss: 1.513 - lr: 8.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.2 - avg_words_per_second: 4732.3 - ETA: >2024-05-26 01:47:01 +2024-05-26 01:20:13 (UTC) - 1:29:27 - train - INFO - step: 000384 - done (%): 76.8 - loss: 1.626 - lr: 8.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.6 - avg_words_per_second: 4734.1 - ETA: >2024-05-26 01:46:59 +2024-05-26 01:20:25 (UTC) - 1:29:38 - train - INFO - step: 000385 - done (%): 77.0 - loss: 1.223 - lr: 8.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.2 - avg_words_per_second: 4735.9 - ETA: >2024-05-26 01:46:56 +2024-05-26 01:20:36 (UTC) - 1:29:50 - train - INFO - step: 000386 - done (%): 77.2 - loss: 1.618 - lr: 8.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.5 - avg_words_per_second: 4737.6 - ETA: >2024-05-26 01:46:53 +2024-05-26 01:20:48 (UTC) - 1:30:02 - train - INFO - step: 000387 - done (%): 77.4 - loss: 1.086 - lr: 8.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.3 - avg_words_per_second: 4739.4 - ETA: >2024-05-26 01:46:51 +2024-05-26 01:21:00 (UTC) - 1:30:14 - train - INFO - step: 000388 - done (%): 77.6 - loss: 1.642 - lr: 7.9e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.9 - avg_words_per_second: 4741.1 - ETA: >2024-05-26 01:46:48 +2024-05-26 01:21:12 (UTC) - 1:30:26 - train - INFO - step: 000389 - done (%): 77.8 - loss: 1.692 - lr: 7.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.5 - avg_words_per_second: 4742.9 - ETA: >2024-05-26 01:46:46 +2024-05-26 01:21:24 (UTC) - 1:30:38 - train - INFO - step: 000390 - done (%): 78.0 - loss: 1.299 - lr: 7.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.2 - avg_words_per_second: 4744.6 - ETA: >2024-05-26 01:46:43 +2024-05-26 01:21:36 (UTC) - 1:30:50 - train - INFO - step: 000391 - done (%): 78.2 - loss: 1.166 - lr: 7.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.9 - avg_words_per_second: 4746.3 - ETA: >2024-05-26 01:46:41 +2024-05-26 01:21:48 (UTC) - 1:31:01 - train - INFO - step: 000392 - done (%): 78.4 - loss: 1.115 - lr: 7.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.5 - avg_words_per_second: 4748.0 - ETA: >2024-05-26 01:46:38 +2024-05-26 01:21:59 (UTC) - 1:31:13 - train - INFO - step: 000393 - done (%): 78.6 - loss: 1.438 - lr: 7.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.1 - avg_words_per_second: 4749.7 - ETA: >2024-05-26 01:46:36 +2024-05-26 01:22:11 (UTC) - 1:31:25 - train - INFO - step: 000394 - done (%): 78.8 - loss: 1.642 - lr: 7.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.0 - avg_words_per_second: 4751.4 - ETA: >2024-05-26 01:46:33 +2024-05-26 01:22:23 (UTC) - 1:31:37 - train - INFO - step: 000395 - done (%): 79.0 - loss: 1.525 - lr: 6.9e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.7 - avg_words_per_second: 4753.1 - ETA: >2024-05-26 01:46:31 +2024-05-26 01:22:35 (UTC) - 1:31:49 - train - INFO - step: 000396 - done (%): 79.2 - loss: 1.468 - lr: 6.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5518.3 - avg_words_per_second: 4754.8 - ETA: >2024-05-26 01:46:28 +2024-05-26 01:22:47 (UTC) - 1:32:01 - train - INFO - step: 000397 - done (%): 79.4 - loss: 1.473 - lr: 6.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5517.0 - avg_words_per_second: 4756.5 - ETA: >2024-05-26 01:46:26 +2024-05-26 01:22:59 (UTC) - 1:32:13 - train - INFO - step: 000398 - done (%): 79.6 - loss: 1.199 - lr: 6.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.9 - avg_words_per_second: 4758.1 - ETA: >2024-05-26 01:46:24 +2024-05-26 01:23:11 (UTC) - 1:32:24 - train - INFO - step: 000399 - done (%): 79.8 - loss: 1.445 - lr: 6.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.1 - avg_words_per_second: 4759.8 - ETA: >2024-05-26 01:46:21 +2024-05-26 01:23:22 (UTC) - 1:32:36 - train - INFO - step: 000400 - done (%): 80.0 - loss: 1.551 - lr: 6.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5517.9 - avg_words_per_second: 4761.4 - ETA: >2024-05-26 01:46:19 +2024-05-26 01:23:22 (UTC) - 1:32:36 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runseed42/checkpoints/checkpoint_000400/consolidated using tmp name: tmp.consolidated +2024-05-26 01:23:37 (UTC) - 1:32:51 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runseed42/checkpoints/checkpoint_000400/consolidated for step: 400 +2024-05-26 01:23:38 (UTC) - 1:32:52 - checkpointing - INFO - Deleted ckpt: /root/mistral-finetune/runseed42/checkpoints/checkpoint_000100 +2024-05-26 01:23:38 (UTC) - 1:32:52 - checkpointing - INFO - Done deleting checkpoints /root/mistral-finetune/runseed42/checkpoints/checkpoint_000100 +2024-05-26 01:23:38 (UTC) - 1:32:52 - checkpointing - INFO - Done! +2024-05-26 01:23:50 (UTC) - 1:33:03 - train - INFO - step: 000401 - done (%): 80.2 - loss: 1.291 - lr: 6.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5598.6 - avg_words_per_second: 4763.2 - ETA: >2024-05-26 01:46:32 +2024-05-26 01:24:01 (UTC) - 1:33:15 - train - INFO - step: 000402 - done (%): 80.4 - loss: 1.632 - lr: 6.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5559.2 - avg_words_per_second: 4764.9 - ETA: >2024-05-26 01:46:29 +2024-05-26 01:24:13 (UTC) - 1:33:27 - train - INFO - step: 000403 - done (%): 80.6 - loss: 1.267 - lr: 6.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.6 - avg_words_per_second: 4766.6 - ETA: >2024-05-26 01:46:27 +2024-05-26 01:24:25 (UTC) - 1:33:39 - train - INFO - step: 000404 - done (%): 80.8 - loss: 1.478 - lr: 5.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.3 - avg_words_per_second: 4768.2 - ETA: >2024-05-26 01:46:24 +2024-05-26 01:24:37 (UTC) - 1:33:51 - train - INFO - step: 000405 - done (%): 81.0 - loss: 1.810 - lr: 5.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.5 - avg_words_per_second: 4769.8 - ETA: >2024-05-26 01:46:22 +2024-05-26 01:24:49 (UTC) - 1:34:02 - train - INFO - step: 000406 - done (%): 81.2 - loss: 1.422 - lr: 5.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.6 - avg_words_per_second: 4771.5 - ETA: >2024-05-26 01:46:20 +2024-05-26 01:25:01 (UTC) - 1:34:14 - train - INFO - step: 000407 - done (%): 81.4 - loss: 1.451 - lr: 5.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.4 - avg_words_per_second: 4773.1 - ETA: >2024-05-26 01:46:17 +2024-05-26 01:25:12 (UTC) - 1:34:26 - train - INFO - step: 000408 - done (%): 81.6 - loss: 1.725 - lr: 5.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.6 - avg_words_per_second: 4774.7 - ETA: >2024-05-26 01:46:15 +2024-05-26 01:25:24 (UTC) - 1:34:38 - train - INFO - step: 000409 - done (%): 81.8 - loss: 1.516 - lr: 5.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.4 - avg_words_per_second: 4776.3 - ETA: >2024-05-26 01:46:13 +2024-05-26 01:25:36 (UTC) - 1:34:50 - train - INFO - step: 000410 - done (%): 82.0 - loss: 1.195 - lr: 5.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.1 - avg_words_per_second: 4777.9 - ETA: >2024-05-26 01:46:11 +2024-05-26 01:25:48 (UTC) - 1:35:02 - train - INFO - step: 000411 - done (%): 82.2 - loss: 1.418 - lr: 5.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.9 - avg_words_per_second: 4779.4 - ETA: >2024-05-26 01:46:08 +2024-05-26 01:26:00 (UTC) - 1:35:14 - train - INFO - step: 000412 - done (%): 82.4 - loss: 1.445 - lr: 4.9e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.4 - avg_words_per_second: 4781.0 - ETA: >2024-05-26 01:46:06 +2024-05-26 01:26:12 (UTC) - 1:35:25 - train - INFO - step: 000413 - done (%): 82.6 - loss: 1.364 - lr: 4.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.2 - avg_words_per_second: 4782.6 - ETA: >2024-05-26 01:46:04 +2024-05-26 01:26:24 (UTC) - 1:35:37 - train - INFO - step: 000414 - done (%): 82.8 - loss: 1.175 - lr: 4.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.5 - avg_words_per_second: 4784.1 - ETA: >2024-05-26 01:46:02 +2024-05-26 01:26:35 (UTC) - 1:35:49 - train - INFO - step: 000415 - done (%): 83.0 - loss: 1.411 - lr: 4.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.8 - avg_words_per_second: 4785.7 - ETA: >2024-05-26 01:45:59 +2024-05-26 01:26:47 (UTC) - 1:36:01 - train - INFO - step: 000416 - done (%): 83.2 - loss: 1.239 - lr: 4.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.0 - avg_words_per_second: 4787.2 - ETA: >2024-05-26 01:45:57 +2024-05-26 01:26:59 (UTC) - 1:36:13 - train - INFO - step: 000417 - done (%): 83.4 - loss: 1.319 - lr: 4.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.3 - avg_words_per_second: 4788.8 - ETA: >2024-05-26 01:45:55 +2024-05-26 01:27:11 (UTC) - 1:36:25 - train - INFO - step: 000418 - done (%): 83.6 - loss: 1.120 - lr: 4.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.2 - avg_words_per_second: 4790.3 - ETA: >2024-05-26 01:45:53 +2024-05-26 01:27:23 (UTC) - 1:36:37 - train - INFO - step: 000419 - done (%): 83.8 - loss: 1.152 - lr: 4.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.9 - avg_words_per_second: 4791.8 - ETA: >2024-05-26 01:45:51 +2024-05-26 01:27:35 (UTC) - 1:36:48 - train - INFO - step: 000420 - done (%): 84.0 - loss: 1.384 - lr: 4.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.1 - avg_words_per_second: 4793.4 - ETA: >2024-05-26 01:45:48 +2024-05-26 01:27:46 (UTC) - 1:37:00 - train - INFO - step: 000421 - done (%): 84.2 - loss: 1.290 - lr: 4.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.6 - avg_words_per_second: 4794.9 - ETA: >2024-05-26 01:45:46 +2024-05-26 01:27:58 (UTC) - 1:37:12 - train - INFO - step: 000422 - done (%): 84.4 - loss: 1.283 - lr: 3.9e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.3 - avg_words_per_second: 4796.4 - ETA: >2024-05-26 01:45:44 +2024-05-26 01:28:10 (UTC) - 1:37:24 - train - INFO - step: 000423 - done (%): 84.6 - loss: 1.301 - lr: 3.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.5 - avg_words_per_second: 4797.9 - ETA: >2024-05-26 01:45:42 +2024-05-26 01:28:22 (UTC) - 1:37:36 - train - INFO - step: 000424 - done (%): 84.8 - loss: 1.491 - lr: 3.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.7 - avg_words_per_second: 4799.4 - ETA: >2024-05-26 01:45:40 +2024-05-26 01:28:34 (UTC) - 1:37:48 - train - INFO - step: 000425 - done (%): 85.0 - loss: 1.415 - lr: 3.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.8 - avg_words_per_second: 4800.9 - ETA: >2024-05-26 01:45:38 +2024-05-26 01:28:46 (UTC) - 1:37:59 - train - INFO - step: 000426 - done (%): 85.2 - loss: 1.563 - lr: 3.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.9 - avg_words_per_second: 4802.4 - ETA: >2024-05-26 01:45:36 +2024-05-26 01:28:58 (UTC) - 1:38:11 - train - INFO - step: 000427 - done (%): 85.4 - loss: 1.616 - lr: 3.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.9 - avg_words_per_second: 4803.9 - ETA: >2024-05-26 01:45:33 +2024-05-26 01:29:09 (UTC) - 1:38:23 - train - INFO - step: 000428 - done (%): 85.6 - loss: 1.405 - lr: 3.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.3 - avg_words_per_second: 4805.3 - ETA: >2024-05-26 01:45:31 +2024-05-26 01:29:21 (UTC) - 1:38:35 - train - INFO - step: 000429 - done (%): 85.8 - loss: 1.442 - lr: 3.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5521.3 - avg_words_per_second: 4806.8 - ETA: >2024-05-26 01:45:29 +2024-05-26 01:29:33 (UTC) - 1:38:47 - train - INFO - step: 000430 - done (%): 86.0 - loss: 1.297 - lr: 3.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.1 - avg_words_per_second: 4808.3 - ETA: >2024-05-26 01:45:27 +2024-05-26 01:29:45 (UTC) - 1:38:59 - train - INFO - step: 000431 - done (%): 86.2 - loss: 1.259 - lr: 3.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.7 - avg_words_per_second: 4809.7 - ETA: >2024-05-26 01:45:25 +2024-05-26 01:29:57 (UTC) - 1:39:11 - train - INFO - step: 000432 - done (%): 86.4 - loss: 0.910 - lr: 3.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.0 - avg_words_per_second: 4811.2 - ETA: >2024-05-26 01:45:23 +2024-05-26 01:30:09 (UTC) - 1:39:22 - train - INFO - step: 000433 - done (%): 86.6 - loss: 1.448 - lr: 2.9e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.3 - avg_words_per_second: 4812.6 - ETA: >2024-05-26 01:45:21 +2024-05-26 01:30:21 (UTC) - 1:39:34 - train - INFO - step: 000434 - done (%): 86.8 - loss: 1.157 - lr: 2.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.4 - avg_words_per_second: 4814.1 - ETA: >2024-05-26 01:45:19 +2024-05-26 01:30:32 (UTC) - 1:39:46 - train - INFO - step: 000435 - done (%): 87.0 - loss: 1.352 - lr: 2.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.0 - avg_words_per_second: 4815.5 - ETA: >2024-05-26 01:45:17 +2024-05-26 01:30:44 (UTC) - 1:39:58 - train - INFO - step: 000436 - done (%): 87.2 - loss: 1.017 - lr: 2.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.1 - avg_words_per_second: 4816.9 - ETA: >2024-05-26 01:45:15 +2024-05-26 01:30:56 (UTC) - 1:40:10 - train - INFO - step: 000437 - done (%): 87.4 - loss: 1.549 - lr: 2.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5509.0 - avg_words_per_second: 4818.3 - ETA: >2024-05-26 01:45:13 +2024-05-26 01:31:08 (UTC) - 1:40:22 - train - INFO - step: 000438 - done (%): 87.6 - loss: 1.701 - lr: 2.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.0 - avg_words_per_second: 4819.7 - ETA: >2024-05-26 01:45:11 +2024-05-26 01:31:20 (UTC) - 1:40:34 - train - INFO - step: 000439 - done (%): 87.8 - loss: 1.438 - lr: 2.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.9 - avg_words_per_second: 4821.1 - ETA: >2024-05-26 01:45:09 +2024-05-26 01:31:32 (UTC) - 1:40:45 - train - INFO - step: 000440 - done (%): 88.0 - loss: 1.199 - lr: 2.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.9 - avg_words_per_second: 4822.6 - ETA: >2024-05-26 01:45:07 +2024-05-26 01:31:44 (UTC) - 1:40:57 - train - INFO - step: 000441 - done (%): 88.2 - loss: 1.247 - lr: 2.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.2 - avg_words_per_second: 4823.9 - ETA: >2024-05-26 01:45:05 +2024-05-26 01:31:55 (UTC) - 1:41:09 - train - INFO - step: 000442 - done (%): 88.4 - loss: 1.633 - lr: 2.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.3 - avg_words_per_second: 4825.3 - ETA: >2024-05-26 01:45:03 +2024-05-26 01:32:07 (UTC) - 1:41:21 - train - INFO - step: 000443 - done (%): 88.6 - loss: 1.249 - lr: 2.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.0 - avg_words_per_second: 4826.7 - ETA: >2024-05-26 01:45:01 +2024-05-26 01:32:19 (UTC) - 1:41:33 - train - INFO - step: 000444 - done (%): 88.8 - loss: 1.201 - lr: 2.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.5 - avg_words_per_second: 4828.1 - ETA: >2024-05-26 01:44:59 +2024-05-26 01:32:31 (UTC) - 1:41:45 - train - INFO - step: 000445 - done (%): 89.0 - loss: 1.664 - lr: 2.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5521.4 - avg_words_per_second: 4829.5 - ETA: >2024-05-26 01:44:57 +2024-05-26 01:32:43 (UTC) - 1:41:57 - train - INFO - step: 000446 - done (%): 89.2 - loss: 1.893 - lr: 1.9e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.3 - avg_words_per_second: 4830.8 - ETA: >2024-05-26 01:44:55 +2024-05-26 01:32:55 (UTC) - 1:42:08 - train - INFO - step: 000447 - done (%): 89.4 - loss: 1.343 - lr: 1.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.8 - avg_words_per_second: 4832.2 - ETA: >2024-05-26 01:44:54 +2024-05-26 01:33:07 (UTC) - 1:42:20 - train - INFO - step: 000448 - done (%): 89.6 - loss: 1.106 - lr: 1.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.4 - avg_words_per_second: 4833.6 - ETA: >2024-05-26 01:44:52 +2024-05-26 01:33:18 (UTC) - 1:42:32 - train - INFO - step: 000449 - done (%): 89.8 - loss: 1.167 - lr: 1.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.7 - avg_words_per_second: 4834.9 - ETA: >2024-05-26 01:44:50 +2024-05-26 01:33:30 (UTC) - 1:42:44 - train - INFO - step: 000450 - done (%): 90.0 - loss: 1.542 - lr: 1.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.6 - avg_words_per_second: 4836.3 - ETA: >2024-05-26 01:44:48 +2024-05-26 01:33:42 (UTC) - 1:42:56 - train - INFO - step: 000451 - done (%): 90.2 - loss: 1.576 - lr: 1.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.2 - avg_words_per_second: 4837.6 - ETA: >2024-05-26 01:44:46 +2024-05-26 01:33:54 (UTC) - 1:43:08 - train - INFO - step: 000452 - done (%): 90.4 - loss: 1.335 - lr: 1.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.4 - avg_words_per_second: 4839.0 - ETA: >2024-05-26 01:44:44 +2024-05-26 01:34:06 (UTC) - 1:43:20 - train - INFO - step: 000453 - done (%): 90.6 - loss: 1.328 - lr: 1.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5504.6 - avg_words_per_second: 4840.2 - ETA: >2024-05-26 01:44:42 +2024-05-26 01:34:18 (UTC) - 1:43:32 - train - INFO - step: 000454 - done (%): 90.8 - loss: 1.866 - lr: 1.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5521.9 - avg_words_per_second: 4841.6 - ETA: >2024-05-26 01:44:40 +2024-05-26 01:34:30 (UTC) - 1:43:43 - train - INFO - step: 000455 - done (%): 91.0 - loss: 1.294 - lr: 1.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.1 - avg_words_per_second: 4842.9 - ETA: >2024-05-26 01:44:39 +2024-05-26 01:34:41 (UTC) - 1:43:55 - train - INFO - step: 000456 - done (%): 91.2 - loss: 1.113 - lr: 1.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.3 - avg_words_per_second: 4844.2 - ETA: >2024-05-26 01:44:37 +2024-05-26 01:34:53 (UTC) - 1:44:07 - train - INFO - step: 000457 - done (%): 91.4 - loss: 0.970 - lr: 1.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.0 - avg_words_per_second: 4845.5 - ETA: >2024-05-26 01:44:35 +2024-05-26 01:35:05 (UTC) - 1:44:19 - train - INFO - step: 000458 - done (%): 91.6 - loss: 1.436 - lr: 1.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.3 - avg_words_per_second: 4846.8 - ETA: >2024-05-26 01:44:33 +2024-05-26 01:35:17 (UTC) - 1:44:31 - train - INFO - step: 000459 - done (%): 91.8 - loss: 1.423 - lr: 1.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.5 - avg_words_per_second: 4848.1 - ETA: >2024-05-26 01:44:31 +2024-05-26 01:35:29 (UTC) - 1:44:43 - train - INFO - step: 000460 - done (%): 92.0 - loss: 1.366 - lr: 1.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.4 - avg_words_per_second: 4849.4 - ETA: >2024-05-26 01:44:29 +2024-05-26 01:35:41 (UTC) - 1:44:54 - train - INFO - step: 000461 - done (%): 92.2 - loss: 1.434 - lr: 9.9e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.9 - avg_words_per_second: 4850.7 - ETA: >2024-05-26 01:44:28 +2024-05-26 01:35:53 (UTC) - 1:45:06 - train - INFO - step: 000462 - done (%): 92.4 - loss: 1.264 - lr: 9.4e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.9 - avg_words_per_second: 4852.0 - ETA: >2024-05-26 01:44:26 +2024-05-26 01:36:04 (UTC) - 1:45:18 - train - INFO - step: 000463 - done (%): 92.6 - loss: 1.380 - lr: 8.9e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5514.6 - avg_words_per_second: 4853.3 - ETA: >2024-05-26 01:44:24 +2024-05-26 01:36:16 (UTC) - 1:45:30 - train - INFO - step: 000464 - done (%): 92.8 - loss: 1.338 - lr: 8.5e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.4 - avg_words_per_second: 4854.6 - ETA: >2024-05-26 01:44:22 +2024-05-26 01:36:28 (UTC) - 1:45:42 - train - INFO - step: 000465 - done (%): 93.0 - loss: 1.444 - lr: 8.0e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.0 - avg_words_per_second: 4855.9 - ETA: >2024-05-26 01:44:20 +2024-05-26 01:36:40 (UTC) - 1:45:54 - train - INFO - step: 000466 - done (%): 93.2 - loss: 1.449 - lr: 7.6e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.5 - avg_words_per_second: 4857.1 - ETA: >2024-05-26 01:44:19 +2024-05-26 01:36:52 (UTC) - 1:46:06 - train - INFO - step: 000467 - done (%): 93.4 - loss: 1.404 - lr: 7.1e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.4 - avg_words_per_second: 4858.4 - ETA: >2024-05-26 01:44:17 +2024-05-26 01:37:04 (UTC) - 1:46:17 - train - INFO - step: 000468 - done (%): 93.6 - loss: 1.458 - lr: 6.7e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.2 - avg_words_per_second: 4859.7 - ETA: >2024-05-26 01:44:15 +2024-05-26 01:37:15 (UTC) - 1:46:29 - train - INFO - step: 000469 - done (%): 93.8 - loss: 1.468 - lr: 6.3e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.0 - avg_words_per_second: 4860.9 - ETA: >2024-05-26 01:44:13 +2024-05-26 01:37:27 (UTC) - 1:46:41 - train - INFO - step: 000470 - done (%): 94.0 - loss: 1.704 - lr: 5.9e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.4 - avg_words_per_second: 4862.2 - ETA: >2024-05-26 01:44:12 +2024-05-26 01:37:51 (UTC) - 1:47:05 - train - INFO - step: 000471 - done (%): 94.2 - loss: 1.269 - lr: 5.5e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 2803.2 - avg_words_per_second: 4854.6 - ETA: >2024-05-26 01:44:22 +2024-05-26 01:38:03 (UTC) - 1:47:16 - train - INFO - step: 000472 - done (%): 94.4 - loss: 1.187 - lr: 5.1e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5554.7 - avg_words_per_second: 4855.9 - ETA: >2024-05-26 01:44:20 +2024-05-26 01:38:14 (UTC) - 1:47:28 - train - INFO - step: 000473 - done (%): 94.6 - loss: 1.277 - lr: 4.8e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5545.2 - avg_words_per_second: 4857.2 - ETA: >2024-05-26 01:44:19 +2024-05-26 01:38:26 (UTC) - 1:47:40 - train - INFO - step: 000474 - done (%): 94.8 - loss: 1.592 - lr: 4.4e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5548.4 - avg_words_per_second: 4858.5 - ETA: >2024-05-26 01:44:17 +2024-05-26 01:38:38 (UTC) - 1:47:52 - train - INFO - step: 000475 - done (%): 95.0 - loss: 1.472 - lr: 4.1e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.0 - avg_words_per_second: 4859.7 - ETA: >2024-05-26 01:44:15 +2024-05-26 01:38:50 (UTC) - 1:48:04 - train - INFO - step: 000476 - done (%): 95.2 - loss: 1.102 - lr: 3.8e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.4 - avg_words_per_second: 4861.0 - ETA: >2024-05-26 01:44:13 +2024-05-26 01:39:02 (UTC) - 1:48:15 - train - INFO - step: 000477 - done (%): 95.4 - loss: 1.606 - lr: 3.5e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.2 - avg_words_per_second: 4862.2 - ETA: >2024-05-26 01:44:12 +2024-05-26 01:39:14 (UTC) - 1:48:27 - train - INFO - step: 000478 - done (%): 95.6 - loss: 1.546 - lr: 3.2e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5523.2 - avg_words_per_second: 4863.4 - ETA: >2024-05-26 01:44:10 +2024-05-26 01:39:25 (UTC) - 1:48:39 - train - INFO - step: 000479 - done (%): 95.8 - loss: 1.463 - lr: 2.9e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.5 - avg_words_per_second: 4864.7 - ETA: >2024-05-26 01:44:08 +2024-05-26 01:39:37 (UTC) - 1:48:51 - train - INFO - step: 000480 - done (%): 96.0 - loss: 1.309 - lr: 2.6e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.2 - avg_words_per_second: 4865.9 - ETA: >2024-05-26 01:44:07 +2024-05-26 01:39:49 (UTC) - 1:49:03 - train - INFO - step: 000481 - done (%): 96.2 - loss: 1.284 - lr: 2.4e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.9 - avg_words_per_second: 4867.1 - ETA: >2024-05-26 01:44:05 +2024-05-26 01:40:01 (UTC) - 1:49:15 - train - INFO - step: 000482 - done (%): 96.4 - loss: 1.577 - lr: 2.1e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.7 - avg_words_per_second: 4868.3 - ETA: >2024-05-26 01:44:03 +2024-05-26 01:40:13 (UTC) - 1:49:27 - train - INFO - step: 000483 - done (%): 96.6 - loss: 1.052 - lr: 1.9e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.0 - avg_words_per_second: 4869.5 - ETA: >2024-05-26 01:44:02 +2024-05-26 01:40:25 (UTC) - 1:49:38 - train - INFO - step: 000484 - done (%): 96.8 - loss: 1.666 - lr: 1.7e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.9 - avg_words_per_second: 4870.7 - ETA: >2024-05-26 01:44:00 +2024-05-26 01:40:37 (UTC) - 1:49:50 - train - INFO - step: 000485 - done (%): 97.0 - loss: 1.372 - lr: 1.5e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5521.8 - avg_words_per_second: 4871.9 - ETA: >2024-05-26 01:43:58 +2024-05-26 01:40:48 (UTC) - 1:50:02 - train - INFO - step: 000486 - done (%): 97.2 - loss: 1.480 - lr: 1.3e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.7 - avg_words_per_second: 4873.1 - ETA: >2024-05-26 01:43:57 +2024-05-26 01:41:00 (UTC) - 1:50:14 - train - INFO - step: 000487 - done (%): 97.4 - loss: 1.451 - lr: 1.1e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.1 - avg_words_per_second: 4874.3 - ETA: >2024-05-26 01:43:55 +2024-05-26 01:41:12 (UTC) - 1:50:26 - train - INFO - step: 000488 - done (%): 97.6 - loss: 1.653 - lr: 9.5e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.5 - avg_words_per_second: 4875.5 - ETA: >2024-05-26 01:43:53 +2024-05-26 01:41:24 (UTC) - 1:50:38 - train - INFO - step: 000489 - done (%): 97.8 - loss: 1.687 - lr: 8.0e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.3 - avg_words_per_second: 4876.7 - ETA: >2024-05-26 01:43:52 +2024-05-26 01:41:36 (UTC) - 1:50:50 - train - INFO - step: 000490 - done (%): 98.0 - loss: 1.623 - lr: 6.6e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.4 - avg_words_per_second: 4877.9 - ETA: >2024-05-26 01:43:50 +2024-05-26 01:41:48 (UTC) - 1:51:01 - train - INFO - step: 000491 - done (%): 98.2 - loss: 1.149 - lr: 5.3e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.1 - avg_words_per_second: 4879.0 - ETA: >2024-05-26 01:43:48 +2024-05-26 01:41:59 (UTC) - 1:51:13 - train - INFO - step: 000492 - done (%): 98.4 - loss: 1.356 - lr: 4.2e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.1 - avg_words_per_second: 4880.2 - ETA: >2024-05-26 01:43:47 +2024-05-26 01:42:11 (UTC) - 1:51:25 - train - INFO - step: 000493 - done (%): 98.6 - loss: 1.355 - lr: 3.2e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.3 - avg_words_per_second: 4881.4 - ETA: >2024-05-26 01:43:45 +2024-05-26 01:42:23 (UTC) - 1:51:37 - train - INFO - step: 000494 - done (%): 98.8 - loss: 1.603 - lr: 2.4e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.4 - avg_words_per_second: 4882.5 - ETA: >2024-05-26 01:43:44 +2024-05-26 01:42:35 (UTC) - 1:51:49 - train - INFO - step: 000495 - done (%): 99.0 - loss: 1.409 - lr: 1.7e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.3 - avg_words_per_second: 4883.7 - ETA: >2024-05-26 01:43:42 +2024-05-26 01:42:47 (UTC) - 1:52:01 - train - INFO - step: 000496 - done (%): 99.2 - loss: 1.444 - lr: 1.1e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.3 - avg_words_per_second: 4884.9 - ETA: >2024-05-26 01:43:40 +2024-05-26 01:42:59 (UTC) - 1:52:12 - train - INFO - step: 000497 - done (%): 99.4 - loss: 1.596 - lr: 6.1e-09 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.4 - avg_words_per_second: 4886.0 - ETA: >2024-05-26 01:43:39 +2024-05-26 01:43:11 (UTC) - 1:52:24 - train - INFO - step: 000498 - done (%): 99.6 - loss: 1.205 - lr: 2.9e-09 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.7 - avg_words_per_second: 4887.2 - ETA: >2024-05-26 01:43:37 +2024-05-26 01:43:22 (UTC) - 1:52:36 - train - INFO - step: 000499 - done (%): 99.8 - loss: 1.490 - lr: 9.0e-10 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.8 - avg_words_per_second: 4888.3 - ETA: >2024-05-26 01:43:36 +2024-05-26 01:43:34 (UTC) - 1:52:48 - train - INFO - step: 000500 - done (%): 100.0 - loss: 1.575 - lr: 2.4e-10 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5520.3 - avg_words_per_second: 4889.4 - ETA: >2024-05-26 01:43:34 +2024-05-26 01:43:34 (UTC) - 1:52:48 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runseed42/checkpoints/checkpoint_000500/consolidated using tmp name: tmp.consolidated +2024-05-26 01:43:49 (UTC) - 1:53:02 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runseed42/checkpoints/checkpoint_000500/consolidated for step: 500 +2024-05-26 01:43:50 (UTC) - 1:53:03 - checkpointing - INFO - Deleted ckpt: /root/mistral-finetune/runseed42/checkpoints/checkpoint_000200 +2024-05-26 01:43:50 (UTC) - 1:53:03 - checkpointing - INFO - Done deleting checkpoints /root/mistral-finetune/runseed42/checkpoints/checkpoint_000200 +2024-05-26 01:43:50 (UTC) - 1:53:03 - checkpointing - INFO - Done! +2024-05-26 01:43:50 (UTC) - 1:53:03 - train - INFO - done! +2024-05-26 01:43:50 (UTC) - 1:53:03 - utils - INFO - Closing: eval_logger \ No newline at end of file diff --git a/runseed42/wandb/run-20240525_235049-kk8bhidf/files/requirements.txt b/runseed42/wandb/run-20240525_235049-kk8bhidf/files/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..f173be0be357b3fd62b7aba8d8c38a23b90cdc07 --- /dev/null +++ b/runseed42/wandb/run-20240525_235049-kk8bhidf/files/requirements.txt @@ -0,0 +1,67 @@ +GitPython==3.1.43 +Jinja2==3.1.4 +Markdown==3.6 +MarkupSafe==2.1.5 +PyYAML==6.0.1 +Werkzeug==3.0.3 +absl-py==2.1.0 +annotated-types==0.7.0 +attrs==23.2.0 +certifi==2024.2.2 +charset-normalizer==3.3.2 +click==8.1.7 +docker-pycreds==0.4.0 +docstring_parser==0.16 +filelock==3.14.0 +fire==0.6.0 +fsspec==2024.5.0 +gitdb==4.0.11 +grpcio==1.64.0 +idna==3.7 +jsonschema-specifications==2023.12.1 +jsonschema==4.21.1 +mistral_common==1.1.0 +mpmath==1.3.0 +networkx==3.3 +numpy==1.26.4 +nvidia-cublas-cu12==12.1.3.1 +nvidia-cuda-cupti-cu12==12.1.105 +nvidia-cuda-nvrtc-cu12==12.1.105 +nvidia-cuda-runtime-cu12==12.1.105 +nvidia-cudnn-cu12==8.9.2.26 +nvidia-cufft-cu12==11.0.2.54 +nvidia-curand-cu12==10.3.2.106 +nvidia-cusolver-cu12==11.4.5.107 +nvidia-cusparse-cu12==12.1.0.106 +nvidia-nccl-cu12==2.19.3 +nvidia-nvjitlink-cu12==12.5.40 +nvidia-nvtx-cu12==12.1.105 +pip==24.0 +platformdirs==4.2.2 +protobuf==4.25.3 +psutil==5.9.8 +pydantic==2.6.1 +pydantic_core==2.16.2 +referencing==0.35.1 +requests==2.32.2 +rpds-py==0.18.1 +safetensors==0.4.3 +sentencepiece==0.1.99 +sentry-sdk==2.3.1 +setproctitle==1.3.3 +setuptools==69.5.1 +simple_parsing==0.1.5 +six==1.16.0 +smmap==5.0.1 +sympy==1.12 +tensorboard-data-server==0.7.2 +tensorboard==2.16.2 +termcolor==2.4.0 +torch==2.2.0 +tqdm==4.66.4 +triton==2.2.0 +typing_extensions==4.12.0 +urllib3==2.2.1 +wandb==0.17.0 +wheel==0.43.0 +xformers==0.0.24 \ No newline at end of file diff --git a/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-metadata.json b/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..161094e8f888774641c073ca9813af54909b75f7 --- /dev/null +++ b/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-metadata.json @@ -0,0 +1,169 @@ +{ + "os": "Linux-5.15.0-102-generic-x86_64-with-glibc2.35", + "python": "3.10.14", + "heartbeatAt": "2024-05-25T23:50:49.643807", + "startedAt": "2024-05-25T23:50:49.202480", + "docker": null, + "cuda": null, + "args": [ + "example/7B.yaml" + ], + "state": "running", + "program": "-m train", + "codePathLocal": null, + "git": { + "remote": "https://github.com/mistralai/mistral-finetune.git", + "commit": "cb892f012ef940bc741dd3b043bc1d06f0cf6085" + }, + "email": "clement.castellon@gmail.com", + "root": "/root/mistral-finetune", + "host": "scw-tender-archimedes", + "username": "root", + "executable": "/root/miniconda/envs/chemistralpy310/bin/python", + "cpu_count": 24, + "cpu_count_logical": 24, + "cpu_freq": { + "current": 2699.9959999999996, + "min": 0.0, + "max": 0.0 + }, + "cpu_freq_per_core": [ + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + } + ], + "disk": { + "/": { + "total": 902.4293403625488, + "used": 231.24297714233398 + } + }, + "gpu": "NVIDIA H100 PCIe", + "gpu_count": 1, + "gpu_devices": [ + { + "name": "NVIDIA H100 PCIe", + "memory_total": 85520809984 + } + ], + "memory": { + "total": 235.9408187866211 + } +} diff --git a/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json b/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json new file mode 100644 index 0000000000000000000000000000000000000000..b79fc0dc3a51516e58e5a3b8913f40c9becf76a1 --- /dev/null +++ b/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json @@ -0,0 +1 @@ +{"train/lr": 2.4e-10, "train/loss": 1.5752968788146973, "train/percent_done": 100.0, "train/peak_allocated_mem": 64.85457944869995, "train/allocated_mem": 24.13963794708252, "train/wps": 5520.256994018846, "train/avg_wps": 4889.437227938565, "train/eta_in_seconds": 0.0, "_timestamp": 1716687814.708857, "_runtime": 6765.504153966904, "_step": 500, "_wandb": {"runtime": 6780}} \ No newline at end of file diff --git a/runseed42/wandb/run-20240525_235049-kk8bhidf/logs/debug-internal.log b/runseed42/wandb/run-20240525_235049-kk8bhidf/logs/debug-internal.log new file mode 100644 index 0000000000000000000000000000000000000000..ded15189af1bfb116c5ead5b313c70d92999be05 --- /dev/null +++ b/runseed42/wandb/run-20240525_235049-kk8bhidf/logs/debug-internal.log @@ -0,0 +1,5580 @@ +2024-05-25 23:50:49,205 INFO StreamThr :53122 [internal.py:wandb_internal():85] W&B internal server running at pid: 53122, started at: 2024-05-25 23:50:49.204916 +2024-05-25 23:50:49,206 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status +2024-05-25 23:50:49,208 INFO WriterThread:53122 [datastore.py:open_for_write():87] open: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/run-kk8bhidf.wandb +2024-05-25 23:50:49,209 DEBUG SenderThread:53122 [sender.py:send():378] send: header +2024-05-25 23:50:49,209 DEBUG SenderThread:53122 [sender.py:send():378] send: run +2024-05-25 23:50:49,547 INFO SenderThread:53122 [dir_watcher.py:__init__():211] watching files in: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files +2024-05-25 23:50:49,547 INFO SenderThread:53122 [sender.py:_start_run_threads():1123] run started: kk8bhidf with start time 1716681049.204703 +2024-05-25 23:50:49,552 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: check_version +2024-05-25 23:50:49,552 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: check_version +2024-05-25 23:50:49,626 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: run_start +2024-05-25 23:50:49,631 DEBUG HandlerThread:53122 [system_info.py:__init__():26] System info init +2024-05-25 23:50:49,631 DEBUG HandlerThread:53122 [system_info.py:__init__():41] System info init done +2024-05-25 23:50:49,631 INFO HandlerThread:53122 [system_monitor.py:start():194] Starting system monitor +2024-05-25 23:50:49,632 INFO SystemMonitor:53122 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-05-25 23:50:49,632 INFO HandlerThread:53122 [system_monitor.py:probe():214] Collecting system info +2024-05-25 23:50:49,632 INFO SystemMonitor:53122 [interfaces.py:start():188] Started cpu monitoring +2024-05-25 23:50:49,633 INFO SystemMonitor:53122 [interfaces.py:start():188] Started disk monitoring +2024-05-25 23:50:49,634 INFO SystemMonitor:53122 [interfaces.py:start():188] Started gpu monitoring +2024-05-25 23:50:49,634 INFO SystemMonitor:53122 [interfaces.py:start():188] Started memory monitoring +2024-05-25 23:50:49,635 INFO SystemMonitor:53122 [interfaces.py:start():188] Started network monitoring +2024-05-25 23:50:49,643 DEBUG HandlerThread:53122 [system_info.py:probe():150] Probing system +2024-05-25 23:50:49,644 DEBUG HandlerThread:53122 [system_info.py:_probe_git():135] Probing git +2024-05-25 23:50:49,648 DEBUG HandlerThread:53122 [system_info.py:_probe_git():143] Probing git done +2024-05-25 23:50:49,648 DEBUG HandlerThread:53122 [system_info.py:probe():198] Probing system done +2024-05-25 23:50:49,648 DEBUG HandlerThread:53122 [system_monitor.py:probe():223] {'os': 'Linux-5.15.0-102-generic-x86_64-with-glibc2.35', 'python': '3.10.14', 'heartbeatAt': '2024-05-25T23:50:49.643807', 'startedAt': '2024-05-25T23:50:49.202480', 'docker': None, 'cuda': None, 'args': ('example/7B.yaml',), 'state': 'running', 'program': '-m train', 'codePathLocal': None, 'git': {'remote': 'https://github.com/mistralai/mistral-finetune.git', 'commit': 'cb892f012ef940bc741dd3b043bc1d06f0cf6085'}, 'email': 'clement.castellon@gmail.com', 'root': '/root/mistral-finetune', 'host': 'scw-tender-archimedes', 'username': 'root', 'executable': '/root/miniconda/envs/chemistralpy310/bin/python', 'cpu_count': 24, 'cpu_count_logical': 24, 'cpu_freq': {'current': 2699.9959999999996, 'min': 0.0, 'max': 0.0}, 'cpu_freq_per_core': [{'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}], 'disk': {'/': {'total': 902.4293403625488, 'used': 231.24297714233398}}, 'gpu': 'NVIDIA H100 PCIe', 'gpu_count': 1, 'gpu_devices': [{'name': 'NVIDIA H100 PCIe', 'memory_total': 85520809984}], 'memory': {'total': 235.9408187866211}} +2024-05-25 23:50:49,648 INFO HandlerThread:53122 [system_monitor.py:probe():224] Finished collecting system info +2024-05-25 23:50:49,648 INFO HandlerThread:53122 [system_monitor.py:probe():227] Publishing system info +2024-05-25 23:50:49,648 DEBUG HandlerThread:53122 [system_info.py:_save_conda():207] Saving list of conda packages installed into the current environment +2024-05-25 23:50:50,548 INFO Thread-12 :53122 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/conda-environment.yaml +2024-05-25 23:50:50,613 DEBUG HandlerThread:53122 [system_info.py:_save_conda():222] Saving conda packages done +2024-05-25 23:50:50,613 INFO HandlerThread:53122 [system_monitor.py:probe():229] Finished publishing system info +2024-05-25 23:50:50,616 DEBUG SenderThread:53122 [sender.py:send():378] send: files +2024-05-25 23:50:50,616 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-metadata.json with policy now +2024-05-25 23:50:50,643 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: python_packages +2024-05-25 23:50:50,644 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: python_packages +2024-05-25 23:50:50,644 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:50:50,644 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:50:50,820 DEBUG SenderThread:53122 [sender.py:send():378] send: telemetry +2024-05-25 23:50:51,091 INFO wandb-upload_0:53122 [upload_job.py:push():130] Uploaded file /tmp/tmpbdm59v8_wandb/wq99sod8-wandb-metadata.json +2024-05-25 23:50:51,548 INFO Thread-12 :53122 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/requirements.txt +2024-05-25 23:50:51,548 INFO Thread-12 :53122 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-25 23:50:51,548 INFO Thread-12 :53122 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-metadata.json +2024-05-25 23:50:53,548 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-25 23:50:54,742 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:50:59,743 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:51:04,744 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:51:05,659 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:51:05,660 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:51:09,806 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:51:14,806 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:51:19,809 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:51:20,554 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/config.yaml +2024-05-25 23:51:20,715 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:51:20,716 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:51:25,851 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:51:30,852 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:51:35,681 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:51:35,681 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:51:35,914 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:51:40,914 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:51:45,915 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:51:49,635 DEBUG SystemMonitor:53122 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-05-25 23:51:49,636 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:51:50,686 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:51:50,686 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:51:50,925 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:51:55,926 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:52:00,927 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:52:05,712 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:52:05,713 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:52:06,917 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:52:11,918 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:52:16,919 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:52:19,636 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:52:20,718 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:52:20,718 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:52:21,947 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:52:26,947 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:52:31,948 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:52:35,718 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:52:35,718 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:52:37,849 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:52:42,849 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:52:47,850 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:52:49,637 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:52:50,702 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:52:50,702 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:52:52,865 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:52:57,865 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:53:02,866 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:53:05,712 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:53:05,713 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:53:07,892 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:53:12,893 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:53:17,894 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:53:19,638 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:53:20,717 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:53:20,718 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:53:23,885 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:53:28,886 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:53:33,886 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:53:35,718 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:53:35,718 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:53:38,897 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:53:43,897 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:53:48,898 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:53:49,638 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:53:50,718 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:53:50,718 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:53:54,889 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:53:59,890 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:54:04,891 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:54:05,719 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:54:05,719 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:54:10,886 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:54:15,887 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:54:19,639 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:54:20,729 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:54:20,729 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:54:20,957 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:54:25,958 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:54:30,959 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:54:35,761 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:54:35,761 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:54:36,939 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:54:41,939 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:54:46,940 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:54:49,639 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:54:50,800 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:54:50,800 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:54:51,967 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:54:56,968 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:55:01,968 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:55:05,761 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:55:05,762 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:55:07,937 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:55:12,937 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:55:17,938 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:55:19,640 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:55:20,756 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:55:20,756 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:55:23,924 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:55:28,925 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:55:33,925 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:55:35,782 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:55:35,782 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:55:39,014 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:55:44,014 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:55:49,015 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:55:49,640 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:55:50,767 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:55:50,767 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:55:54,945 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:55:59,945 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:56:04,946 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:56:05,772 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:56:05,772 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:56:09,996 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:56:14,997 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:56:19,641 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:56:20,641 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:56:20,772 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:56:20,772 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:56:26,002 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:56:31,002 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:56:35,783 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:56:35,783 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:56:36,917 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:56:41,918 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:56:46,919 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:56:49,641 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:56:50,819 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:56:50,819 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:56:51,955 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:56:56,956 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:57:01,956 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:57:05,845 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:57:05,845 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:57:07,010 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:57:12,010 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:57:17,011 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:57:19,642 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:57:20,804 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:57:20,804 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:57:22,028 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:57:27,029 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:57:32,029 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:57:35,822 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:57:35,823 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:57:37,039 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:57:42,040 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:57:47,040 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:57:49,642 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:57:50,847 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:57:50,847 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:57:52,074 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:57:57,075 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:58:02,075 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:58:05,852 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:58:05,852 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:58:07,079 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:58:12,080 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:58:17,080 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:58:19,643 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:58:20,831 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:58:20,831 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:58:23,059 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:58:28,059 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:58:33,060 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:58:35,820 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:58:35,821 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:58:39,048 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:58:44,048 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:58:49,049 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:58:49,644 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:58:50,853 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:58:50,854 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:58:55,014 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:59:00,015 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:59:05,016 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:59:05,832 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:59:05,832 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:59:10,965 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:59:15,966 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:59:19,644 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:59:20,853 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:59:20,854 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:59:20,997 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:59:25,998 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:59:30,998 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:59:35,843 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:59:35,843 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:59:36,010 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:59:41,010 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:59:46,011 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:59:49,645 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-25 23:59:51,645 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:59:52,919 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:59:52,919 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:59:57,041 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:00:02,042 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:00:07,042 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:00:07,966 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:00:07,966 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:00:12,277 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:00:17,278 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:00:19,645 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:00:22,646 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:00:22,960 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:00:22,960 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:00:28,191 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:00:33,192 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:00:37,966 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:00:37,966 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:00:39,170 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:00:44,170 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:00:49,171 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:00:49,646 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:00:52,971 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:00:52,971 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:00:54,193 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:00:59,194 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:01:04,194 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:01:07,977 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:01:07,977 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:01:10,154 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:01:15,155 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:01:19,646 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:01:20,647 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:01:22,993 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:01:22,994 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:01:26,171 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:01:31,172 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:01:36,172 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:01:38,000 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:01:38,000 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:01:41,217 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:01:46,217 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:01:49,650 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:01:51,651 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:01:52,990 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:01:52,990 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:01:57,211 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:02:02,211 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:02:07,212 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:02:07,983 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:02:07,983 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:02:13,201 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:02:18,202 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:02:19,647 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:02:22,998 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:02:22,998 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:02:23,221 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:02:28,222 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:02:33,222 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:02:38,008 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:02:38,008 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:02:39,148 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:02:44,149 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:02:49,149 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:02:49,649 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:02:52,998 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:02:52,999 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:02:54,152 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:02:59,152 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:03:04,153 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:03:08,027 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:03:08,027 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:03:09,226 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:03:09,700 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:03:11,701 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:03:14,227 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:03:19,227 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:03:19,648 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:03:21,270 DEBUG SenderThread:53122 [sender.py:send():378] send: telemetry +2024-05-26 00:03:21,270 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:03:22,983 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:03:22,983 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:03:23,703 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:03:25,117 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:03:30,118 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:03:32,919 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:03:32,920 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:03:32,920 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:03:32,920 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:03:33,705 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:03:33,705 INFO Thread-12 :53122 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:03:35,921 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:03:37,983 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:03:37,983 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:03:41,142 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:03:44,621 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:03:44,621 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:03:44,621 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:03:44,622 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:03:44,708 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:03:46,624 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:03:46,708 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:03:47,708 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/config.yaml +2024-05-26 00:03:49,649 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:03:52,650 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:03:52,983 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:03:52,983 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:03:56,480 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:03:56,481 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:03:56,481 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:03:56,481 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:03:56,710 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:03:58,482 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:03:58,711 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:04:03,482 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:04:07,983 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:04:07,983 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:04:08,263 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:04:08,264 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:04:08,264 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:04:08,264 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:04:08,713 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:04:09,264 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:04:10,714 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:04:14,265 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:04:19,265 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:04:19,649 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:04:20,055 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:04:20,056 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:04:20,056 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:04:20,056 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:04:20,716 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:04:22,716 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:04:22,983 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:04:22,983 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:04:25,138 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:04:30,139 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:04:31,880 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:04:31,881 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:04:31,881 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:04:31,881 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:04:32,719 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:04:34,719 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:04:35,882 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:04:37,983 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:04:37,984 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:04:41,175 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:04:43,699 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:04:43,699 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:04:43,699 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:04:43,700 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:04:43,721 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:04:44,721 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:04:46,700 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:04:49,650 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:04:52,651 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:04:52,983 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:04:52,984 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:04:55,518 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:04:55,519 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:04:55,519 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:04:55,519 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:04:55,724 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:04:56,724 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:04:58,520 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:05:03,521 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:05:07,358 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:05:07,358 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:05:07,359 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:05:07,359 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:05:07,726 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:05:07,984 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:05:07,984 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:05:08,727 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:05:09,120 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:05:14,120 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:05:19,121 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:05:19,196 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:05:19,196 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:05:19,197 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:05:19,197 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:05:19,650 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:05:19,729 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:05:20,730 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:05:22,984 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:05:22,984 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:05:24,214 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:05:29,215 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:05:31,032 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:05:31,032 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:05:31,033 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:05:31,033 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:05:31,732 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:05:32,732 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:05:35,033 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:05:37,984 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:05:37,984 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:05:40,202 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:05:42,873 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:05:42,874 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:05:42,874 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:05:42,874 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:05:43,735 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:05:44,735 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:05:45,875 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:05:49,651 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:05:51,652 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:05:52,984 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:05:52,984 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:05:54,699 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:05:54,699 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:05:54,699 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:05:54,700 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:05:54,738 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:05:56,700 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:05:56,738 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:06:01,701 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:06:06,522 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:06:06,523 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:06:06,523 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:06:06,523 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:06:06,740 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:06:07,524 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:06:07,984 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:06:07,984 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:06:08,741 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:06:13,127 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:06:18,128 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:06:18,347 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:06:18,348 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:06:18,348 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:06:18,348 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:06:18,743 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:06:19,651 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:06:20,743 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:06:22,984 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:06:22,984 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:06:23,199 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:06:28,199 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:06:30,168 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:06:30,169 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:06:30,169 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:06:30,170 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:06:30,745 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:06:32,746 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:06:34,170 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:06:37,984 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:06:37,984 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:06:40,136 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:06:42,000 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:06:42,001 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:06:42,001 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:06:42,001 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:06:42,748 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:06:44,749 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:06:46,002 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:06:49,652 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:06:51,653 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:06:52,984 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:06:52,985 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:06:53,841 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:06:53,841 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:06:53,841 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:06:53,842 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:06:54,751 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:06:54,751 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:06:56,842 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:07:01,843 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:07:05,681 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:07:05,682 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:07:05,682 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:07:05,682 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:07:05,753 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:07:06,753 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:07:07,683 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:07:07,984 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:07:07,985 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:07:13,184 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:07:17,517 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:07:17,518 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:07:17,518 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:07:17,518 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:07:17,756 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:07:18,519 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:07:18,756 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:07:19,652 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:07:22,985 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:07:22,985 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:07:24,179 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:07:29,180 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:07:29,348 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:07:29,356 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:07:29,356 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:07:29,357 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:07:29,758 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:07:30,759 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:07:34,357 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:07:37,985 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:07:37,985 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:07:40,215 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:07:41,162 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:07:41,162 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:07:41,163 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:07:41,163 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:07:41,761 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:07:42,761 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:07:46,164 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:07:49,653 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:07:51,653 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:07:52,985 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:07:52,985 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:07:53,026 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:07:53,190 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:07:53,190 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:07:53,190 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:07:53,764 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:07:54,764 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:07:57,191 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:08:02,192 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:08:04,833 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:08:04,833 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:08:04,833 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:08:04,834 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:08:05,766 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:08:06,767 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:08:07,834 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:08:07,985 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:08:07,985 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:08:13,207 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:08:16,669 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:08:16,670 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:08:16,670 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:08:16,670 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:08:16,769 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:08:18,671 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:08:18,769 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:08:19,653 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:08:22,985 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:08:22,985 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:08:24,195 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:08:28,517 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:08:28,517 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:08:28,517 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:08:28,518 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:08:28,771 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:08:29,518 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:08:30,772 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:08:34,519 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:08:37,985 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:08:37,985 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:08:40,188 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:08:40,369 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:08:40,370 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:08:40,370 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:08:40,370 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:08:40,775 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:08:42,775 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:08:45,371 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:08:49,654 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:08:50,655 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:08:52,237 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:08:52,238 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:08:52,238 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:08:52,238 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:08:52,777 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:08:52,985 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:08:52,985 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:08:54,778 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:08:56,123 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:09:01,124 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:09:04,068 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:09:04,069 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:09:04,069 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:09:04,070 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:09:04,781 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:09:04,781 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:09:07,070 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:09:07,985 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:09:07,986 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:09:12,207 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:09:15,882 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:09:15,883 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:09:15,883 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:09:15,883 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:09:16,784 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:09:16,784 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:09:17,884 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:09:19,654 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:09:22,976 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:09:22,985 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:09:22,986 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:09:27,757 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:09:27,758 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:09:27,758 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:09:27,758 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:09:27,786 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:09:28,759 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:09:28,787 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:09:33,759 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:09:37,986 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:09:37,986 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:09:39,194 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:09:39,605 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:09:39,605 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:09:39,606 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:09:39,606 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:09:39,789 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:09:40,789 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:09:44,607 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:09:49,607 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:09:49,655 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:09:51,450 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:09:51,451 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:09:51,451 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:09:51,452 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:09:51,792 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:09:52,792 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:09:52,986 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:09:52,986 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:09:55,204 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:10:00,204 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:10:03,280 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:10:03,281 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:10:03,281 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:10:03,281 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:10:03,795 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:10:04,795 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:10:05,282 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:10:07,986 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:10:07,986 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:10:11,199 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:10:15,123 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:10:15,123 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:10:15,124 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:10:15,124 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:10:15,798 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:10:16,799 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:10:17,124 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:10:19,655 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:10:22,656 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:10:22,986 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:10:22,986 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:10:26,985 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:10:26,985 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:10:26,986 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:10:26,986 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:10:27,801 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:10:27,986 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:10:28,802 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:10:32,987 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:10:37,986 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:10:37,987 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:10:38,186 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:10:38,858 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:10:38,859 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:10:38,859 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:10:38,859 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:10:39,804 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:10:40,805 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:10:43,860 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:10:48,860 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:10:49,656 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:10:50,681 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:10:50,682 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:10:50,682 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:10:50,682 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:10:50,807 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:10:52,808 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:10:52,986 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:10:52,986 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:10:54,148 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:10:59,149 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:11:02,503 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:11:02,504 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:11:02,504 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:11:02,505 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:11:02,811 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:11:04,505 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:11:04,811 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:11:07,986 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:11:07,986 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:11:10,214 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:11:14,345 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:11:14,345 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:11:14,346 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:11:14,346 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:11:14,814 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:11:15,346 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:11:16,815 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:11:19,656 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:11:20,657 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:11:22,986 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:11:22,987 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:11:26,171 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:11:26,172 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:11:26,172 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:11:26,172 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:11:26,172 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:11:26,818 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:11:26,818 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:11:31,173 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:11:36,174 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:11:37,986 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:11:37,987 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:11:38,030 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:11:38,124 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:11:38,124 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:11:38,125 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:11:38,821 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:11:38,821 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:11:42,125 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:11:47,126 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:11:49,657 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:11:49,858 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:11:49,859 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:11:49,859 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:11:49,859 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:11:50,824 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:11:50,825 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:11:52,860 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:11:52,987 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:11:52,987 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:11:58,182 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:12:01,725 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:12:01,725 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:12:01,726 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:12:01,726 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:12:01,827 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:12:02,828 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:12:03,726 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:12:07,987 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:12:07,987 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:12:09,190 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:12:13,543 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:12:13,543 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:12:13,544 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:12:13,544 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:12:13,830 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:12:14,544 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:12:14,831 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:12:19,545 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:12:19,661 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:12:22,987 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:12:22,987 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:12:25,162 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:12:25,393 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:12:25,393 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:12:25,394 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:12:25,394 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:12:25,834 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:12:26,834 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:12:30,395 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:12:35,395 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:12:37,227 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:12:37,228 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:12:37,228 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:12:37,228 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:12:37,837 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:12:37,987 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:12:37,987 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:12:38,837 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:12:41,218 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:12:46,218 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:12:49,041 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:12:49,042 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:12:49,042 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:12:49,042 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:12:49,658 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:12:49,840 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:12:50,840 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:12:51,659 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:12:52,993 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:12:52,993 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:12:57,162 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:13:00,914 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:13:00,915 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:13:00,915 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:13:00,915 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:13:01,843 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:13:02,843 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:13:02,915 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:13:07,916 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:13:07,993 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:13:07,993 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:13:12,746 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:13:12,746 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:13:12,747 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:13:12,747 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:13:12,845 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:13:13,747 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:13:14,846 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:13:18,748 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:13:19,658 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:13:22,993 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:13:22,993 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:13:24,176 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:13:24,570 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:13:24,570 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:13:24,571 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:13:24,572 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:13:24,848 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:13:26,848 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:13:29,572 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:13:34,573 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:13:36,362 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:13:36,362 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:13:36,363 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:13:36,363 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:13:36,851 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:13:36,851 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:13:37,993 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:13:37,994 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:13:40,173 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:13:45,173 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:13:48,234 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:13:48,234 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:13:48,235 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:13:48,235 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:13:48,853 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:13:48,853 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:13:49,659 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:13:50,660 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:13:52,993 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:13:52,993 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:13:56,149 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:14:00,039 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:14:00,040 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:14:00,040 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:14:00,041 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:14:00,856 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:14:00,856 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:14:02,041 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:14:07,042 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:14:07,993 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:14:07,993 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:14:11,914 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:14:11,914 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:14:11,915 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:14:11,915 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:14:12,859 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:14:12,859 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:14:12,915 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:14:17,916 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:14:19,660 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:14:22,994 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:14:22,994 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:14:22,994 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:14:23,762 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:14:23,763 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:14:23,763 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:14:23,763 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:14:23,861 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:14:24,861 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:14:28,764 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:14:33,764 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:14:35,567 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:14:35,568 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:14:35,568 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:14:35,569 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:14:35,864 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:14:36,864 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:14:37,993 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:14:37,994 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:14:39,203 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:14:44,204 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:14:47,466 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:14:47,466 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:14:47,467 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:14:47,467 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:14:47,866 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:14:48,866 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:14:49,467 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:14:49,660 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:14:52,994 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:14:52,994 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:14:55,147 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:14:59,302 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:14:59,303 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:14:59,303 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:14:59,303 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:14:59,869 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:15:00,303 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:15:00,869 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:15:05,304 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:15:07,994 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:15:07,994 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:15:11,092 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:15:11,134 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:15:11,134 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:15:11,135 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:15:11,136 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:15:11,871 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:15:12,872 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:15:16,136 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:15:19,661 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:15:21,661 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:15:22,940 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:15:22,940 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:15:22,941 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:15:22,941 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:15:22,995 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:15:22,995 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:15:23,874 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:15:24,874 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:15:27,172 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:15:32,172 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:15:34,834 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:15:34,835 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:15:34,835 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:15:34,835 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:15:34,877 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:15:36,877 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:15:37,836 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:15:37,994 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:15:37,994 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:15:43,194 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:15:46,682 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:15:46,683 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:15:46,683 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:15:46,684 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:15:46,879 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:15:48,684 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:15:48,880 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:15:49,661 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:15:52,994 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:15:52,994 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:15:54,144 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:15:58,510 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:15:58,510 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:15:58,511 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:15:58,511 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:15:58,882 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:15:58,882 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:15:59,511 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:16:04,512 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:16:07,994 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:16:07,995 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:16:10,200 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:16:10,354 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:16:10,355 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:16:10,355 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:16:10,355 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:16:10,885 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:16:10,885 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:16:15,356 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:16:19,662 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:16:20,662 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:16:22,132 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:16:22,133 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:16:22,133 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:16:22,133 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:16:22,887 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:16:22,887 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:16:22,995 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:16:22,996 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:16:26,147 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:16:31,147 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:16:33,955 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:16:33,956 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:16:33,956 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:16:33,956 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:16:34,890 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:16:34,890 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:16:36,957 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:16:37,995 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:16:37,995 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:16:42,228 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:16:45,826 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:16:45,826 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:16:45,827 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:16:45,827 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:16:45,892 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:16:46,892 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:16:47,827 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:16:49,662 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:16:52,996 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:16:52,996 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:16:53,159 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:16:57,627 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:16:57,627 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:16:57,627 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:16:57,628 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:16:57,894 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:16:58,628 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:16:58,895 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:17:03,629 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:17:07,995 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:17:07,995 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:17:09,209 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:17:09,466 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:17:09,467 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:17:09,467 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:17:09,467 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:17:09,897 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:17:10,897 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:17:14,468 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:17:19,469 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:17:19,671 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:17:21,312 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:17:21,312 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:17:21,313 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:17:21,313 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:17:21,900 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:17:22,900 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:17:22,995 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:17:22,995 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:17:25,117 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:17:30,117 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:17:33,198 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:17:33,199 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:17:33,199 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:17:33,199 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:17:33,903 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:17:34,903 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:17:35,200 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:17:37,995 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:17:37,996 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:17:41,187 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:17:45,032 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:17:45,033 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:17:45,033 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:17:45,033 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:17:45,906 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:17:46,906 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:17:47,034 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:17:49,663 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:17:52,664 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:17:52,995 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:17:52,996 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:17:56,850 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:17:56,851 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:17:56,851 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:17:56,852 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:17:56,908 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:17:57,853 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:17:58,909 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:18:02,853 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:18:07,854 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:18:07,995 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:18:07,996 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:18:08,672 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:18:08,672 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:18:08,672 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:18:08,673 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:18:08,911 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:18:08,911 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:18:13,673 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:18:18,674 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:18:19,664 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:18:20,515 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:18:20,515 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:18:20,516 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:18:20,516 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:18:20,914 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:18:20,914 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:18:22,995 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:18:22,996 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:18:24,229 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:18:29,230 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:18:32,342 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:18:32,343 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:18:32,343 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:18:32,344 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:18:32,917 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:18:32,917 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:18:34,344 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:18:37,996 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:18:37,996 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:18:40,200 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:18:44,158 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:18:44,158 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:18:44,159 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:18:44,159 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:18:44,919 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:18:44,920 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:18:46,159 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:18:49,664 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:18:51,665 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:18:52,996 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:18:52,996 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:18:55,974 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:18:55,974 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:18:55,974 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:18:55,975 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:18:56,922 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:18:56,922 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:18:56,975 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:19:01,976 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:19:06,976 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:19:07,826 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:19:07,827 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:19:07,827 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:19:07,828 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:19:07,925 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:19:07,996 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:19:07,996 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:19:08,925 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:19:12,161 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:19:17,162 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:19:19,665 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:19:19,678 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:19:19,679 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:19:19,679 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:19:19,679 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:19:19,927 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:19:20,928 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:19:22,679 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:19:22,996 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:19:22,996 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:19:28,180 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:19:31,500 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:19:31,500 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:19:31,501 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:19:31,501 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:19:31,930 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:19:32,930 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:19:33,501 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:19:37,996 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:19:37,996 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:19:39,190 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:19:43,343 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:19:43,343 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:19:43,343 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:19:43,344 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:19:43,933 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:19:44,345 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:19:44,933 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:19:49,345 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:19:49,665 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:19:52,996 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:19:52,997 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:19:55,150 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:19:55,208 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:19:55,209 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:19:55,209 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:19:55,209 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:19:55,936 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:19:56,936 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:20:00,210 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:20:05,211 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:20:07,035 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:20:07,036 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:20:07,036 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:20:07,037 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:20:07,939 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:20:07,996 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:20:07,997 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:20:08,939 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:20:11,137 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:20:16,138 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:20:18,884 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:20:18,885 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:20:18,885 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:20:18,886 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:20:18,942 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:20:19,666 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:20:20,942 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:20:21,667 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:20:22,996 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:20:22,997 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:20:27,205 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:20:30,734 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:20:30,734 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:20:30,734 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:20:30,735 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:20:30,944 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:20:30,945 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:20:32,735 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:20:37,736 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:20:37,996 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:20:37,997 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:20:42,583 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:20:42,584 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:20:42,584 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:20:42,585 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:20:42,948 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:20:42,948 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:20:43,585 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:20:48,586 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:20:49,666 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:20:52,997 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:20:52,997 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:20:54,199 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:20:54,437 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:20:54,438 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:20:54,438 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:20:54,438 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:20:54,951 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:20:54,951 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:20:59,439 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:21:04,440 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:21:06,348 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:21:06,348 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:21:06,348 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:21:06,349 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:21:06,954 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:21:06,954 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:21:07,997 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:21:07,997 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:21:10,203 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:21:15,204 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:21:18,196 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:21:18,197 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:21:18,197 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:21:18,197 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:21:18,956 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:21:18,957 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:21:19,667 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:21:20,667 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:21:22,997 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:21:22,997 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:21:26,226 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:21:30,084 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:21:30,085 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:21:30,085 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:21:30,085 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:21:30,959 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:21:30,960 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:21:32,086 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:21:37,086 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:21:37,997 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:21:37,997 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:21:41,993 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:21:41,994 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:21:41,994 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:21:41,994 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:21:42,962 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:21:42,995 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:21:43,963 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:21:47,995 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:21:49,667 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:21:52,997 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:21:52,998 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:21:53,117 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:21:53,826 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:21:53,827 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:21:53,827 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:21:53,827 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:21:53,965 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:21:55,965 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:21:58,828 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:22:03,829 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:22:05,701 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:22:05,702 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:22:05,702 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:22:05,702 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:22:05,968 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:22:07,968 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:22:07,999 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:22:08,000 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:22:09,139 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:22:14,140 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:22:17,522 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:22:17,527 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:22:17,527 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:22:17,527 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:22:17,971 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:22:19,528 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:22:19,668 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:22:19,971 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:22:22,998 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:22:22,998 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:22:25,193 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:22:29,388 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:22:29,389 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:22:29,389 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:22:29,389 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:22:29,973 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:22:30,390 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:22:31,974 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:22:35,390 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:22:37,998 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:22:37,998 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:22:41,228 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:22:41,235 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:22:41,236 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:22:41,236 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:22:41,236 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:22:41,976 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:22:43,977 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:22:46,237 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:22:49,668 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:22:51,669 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:22:52,998 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:22:52,998 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:22:53,068 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:22:53,155 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:22:53,155 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:22:53,156 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:22:53,979 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:22:55,980 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:22:57,156 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:23:02,157 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:23:07,158 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:23:07,998 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:23:07,998 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:23:09,983 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:23:12,173 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:23:17,174 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:23:19,492 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:23:19,492 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:23:19,492 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:23:19,623 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:23:19,669 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:23:19,986 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:23:21,986 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:23:22,670 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:23:22,998 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:23:22,998 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:23:28,156 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:23:31,267 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:23:31,268 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:23:31,268 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:23:31,268 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:23:31,989 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:23:33,269 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:23:33,989 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:23:37,998 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:23:37,998 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:23:39,211 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:23:43,070 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:23:43,071 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:23:43,071 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:23:43,071 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:23:43,992 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:23:45,072 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:23:45,992 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:23:49,670 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:23:50,670 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:23:52,998 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:23:52,999 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:23:54,902 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:23:54,903 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:23:54,903 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:23:54,903 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:23:54,995 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:23:55,903 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:23:55,995 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:24:00,904 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:24:05,905 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:24:06,749 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:24:06,749 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:24:06,750 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:24:06,750 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:24:06,999 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:24:07,998 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:24:07,999 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:24:08,001 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:24:11,197 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:24:16,198 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:24:18,601 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:24:18,602 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:24:18,602 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:24:18,602 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:24:19,003 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:24:19,670 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:24:20,004 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:24:21,671 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:24:26,671 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:24:31,050 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:24:31,050 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:24:32,251 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:24:37,252 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:24:39,714 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:24:39,714 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:24:39,715 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:24:39,715 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:24:40,008 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:24:42,009 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:24:42,715 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:24:46,050 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:24:46,050 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:24:48,217 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:24:49,670 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:24:51,486 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:24:51,486 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:24:51,487 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:24:51,487 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:24:52,011 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:24:53,487 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:24:54,012 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:24:58,488 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:25:01,050 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:25:01,051 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:25:03,306 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:25:03,306 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:25:03,307 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:25:03,307 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:25:04,014 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:25:04,307 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:25:06,015 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:25:09,308 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:25:14,309 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:25:15,097 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:25:15,098 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:25:15,098 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:25:15,098 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:25:16,017 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:25:16,018 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:25:16,050 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:25:16,051 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:25:19,671 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:25:19,671 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:25:24,672 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:25:26,978 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:25:26,978 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:25:26,979 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:25:26,979 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:25:27,020 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:25:28,020 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:25:29,979 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:25:31,050 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:25:31,051 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:25:35,234 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:25:38,846 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:25:38,846 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:25:38,847 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:25:38,847 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:25:39,023 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:25:40,023 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:25:40,847 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:25:45,848 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:25:46,050 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:25:46,051 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:25:49,671 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:25:50,682 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:25:50,682 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:25:50,683 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:25:50,683 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:25:51,026 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:25:51,683 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:25:52,026 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:25:56,684 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:26:01,051 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:26:01,051 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:26:02,284 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:26:02,542 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:26:02,542 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:26:02,543 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:26:02,543 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:26:03,029 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:26:04,029 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:26:07,543 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:26:12,544 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:26:14,350 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:26:14,350 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:26:14,350 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:26:14,351 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:26:15,032 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:26:16,032 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:26:16,051 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:26:16,051 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:26:18,201 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:26:19,672 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:26:23,673 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:26:26,226 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:26:26,226 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:26:26,227 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:26:26,227 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:26:27,034 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:26:28,035 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:26:29,227 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:26:31,051 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:26:31,051 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:26:34,263 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:26:38,074 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:26:38,074 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:26:38,075 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:26:38,075 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:26:39,037 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:26:40,038 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:26:40,075 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:26:45,076 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:26:46,051 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:26:46,051 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:26:49,672 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:26:49,914 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:26:49,914 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:26:49,915 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:26:49,915 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:26:50,040 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:26:50,915 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:26:52,041 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:26:55,916 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:27:00,917 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:27:01,051 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:27:01,051 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:27:01,717 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:27:01,718 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:27:01,718 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:27:01,718 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:27:02,043 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:27:04,043 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:27:06,719 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:27:11,720 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:27:13,552 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:27:13,552 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:27:13,552 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:27:13,553 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:27:14,046 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:27:16,046 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:27:16,051 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:27:16,051 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:27:17,252 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:27:19,676 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:27:22,677 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:27:25,442 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:27:25,442 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:27:25,443 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:27:25,443 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:27:26,049 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:27:28,049 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:27:28,444 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:27:31,051 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:27:31,052 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:27:34,249 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:27:37,282 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:27:37,282 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:27:37,283 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:27:37,283 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:27:38,052 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:27:38,052 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:27:39,283 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:27:44,284 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:27:46,052 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:27:46,052 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:27:49,095 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:27:49,095 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:27:49,095 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:27:49,096 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:27:49,673 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:27:49,674 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:27:50,055 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:27:50,055 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:27:54,675 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:27:59,675 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:28:00,941 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:28:00,941 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:28:00,942 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:28:00,943 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:28:01,052 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:28:01,052 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:28:01,058 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:28:02,058 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:28:05,190 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:28:10,191 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:28:12,780 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:28:12,781 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:28:12,781 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:28:12,781 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:28:13,061 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:28:14,061 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:28:15,782 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:28:16,052 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:28:16,052 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:28:19,674 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:28:21,675 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:28:24,682 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:28:24,682 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:28:24,683 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:28:24,683 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:28:25,064 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:28:26,065 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:28:26,683 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:28:31,052 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:28:31,052 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:28:32,191 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:28:36,538 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:28:36,538 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:28:36,539 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:28:36,540 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:28:37,067 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:28:37,540 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:28:38,068 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:28:42,541 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:28:46,052 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:28:46,052 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:28:48,214 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:28:48,382 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:28:48,382 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:28:48,383 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:28:48,383 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:28:49,071 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:28:49,674 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:28:50,071 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:28:53,676 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:28:58,676 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:29:00,189 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:29:00,190 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:29:00,190 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:29:00,190 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:29:01,052 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:29:01,052 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:29:01,074 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:29:02,074 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:29:04,231 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:29:09,232 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:29:12,058 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:29:12,058 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:29:12,059 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:29:12,060 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:29:12,077 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:29:14,077 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:29:15,060 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:29:16,052 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:29:16,052 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:29:19,675 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:29:20,676 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:29:23,970 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:29:23,970 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:29:23,971 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:29:23,971 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:29:24,080 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:29:25,971 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:29:26,081 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:29:30,972 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:29:31,052 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:29:31,053 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:29:35,806 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:29:35,806 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:29:35,807 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:29:35,807 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:29:36,083 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:29:36,807 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:29:38,084 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:29:41,808 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:29:46,052 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:29:46,053 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:29:47,269 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:29:47,650 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:29:47,650 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:29:47,651 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:29:47,652 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:29:48,086 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:29:49,676 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:29:50,087 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:29:52,676 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:29:57,677 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:29:59,454 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:29:59,455 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:29:59,455 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:29:59,455 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:30:00,090 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:30:00,090 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:30:01,053 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:30:01,053 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:30:03,237 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:30:08,238 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:30:11,330 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:30:11,330 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:30:11,331 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:30:11,331 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:30:12,093 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:30:12,093 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:30:13,331 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:30:16,053 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:30:16,053 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:30:19,271 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:30:19,676 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:30:23,206 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:30:23,207 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:30:23,207 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:30:23,207 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:30:24,096 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:30:24,096 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:30:25,208 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:30:30,208 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:30:31,053 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:30:31,053 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:30:35,046 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:30:35,046 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:30:35,047 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:30:35,047 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:30:35,099 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:30:36,047 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:30:36,099 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:30:41,048 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:30:46,049 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:30:46,053 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:30:46,053 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:30:46,845 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:30:46,845 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:30:46,845 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:30:46,846 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:30:47,102 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:30:48,102 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:30:49,677 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:30:51,677 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:30:56,678 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:30:58,721 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:30:58,721 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:30:58,722 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:30:58,722 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:30:59,104 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:31:00,105 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:31:01,053 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:31:01,053 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:31:02,198 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:31:07,199 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:31:10,586 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:31:10,586 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:31:10,587 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:31:10,587 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:31:11,107 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:31:12,108 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:31:12,587 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:31:16,053 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:31:16,053 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:31:18,240 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:31:19,677 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:31:22,450 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:31:22,450 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:31:22,451 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:31:22,451 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:31:23,110 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:31:23,451 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:31:24,110 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:31:28,452 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:31:31,053 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:31:31,054 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:31:34,234 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:31:34,294 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:31:34,294 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:31:34,295 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:31:34,295 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:31:35,113 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:31:36,113 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:31:39,296 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:31:44,297 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:31:46,053 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:31:46,054 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:31:46,150 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:31:46,200 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:31:46,200 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:31:46,200 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:31:47,116 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:31:48,116 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:31:49,678 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:31:49,678 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:31:54,679 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:31:57,943 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:31:57,944 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:31:57,944 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:31:57,945 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:31:58,118 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:31:59,945 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:32:00,119 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:32:01,053 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:32:01,054 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:32:05,231 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:32:09,826 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:32:09,830 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:32:09,830 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:32:09,830 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:32:10,121 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:32:10,831 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:32:12,121 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:32:15,831 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:32:16,054 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:32:16,054 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:32:19,678 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:32:21,629 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:32:21,670 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:32:21,670 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:32:21,671 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:32:21,671 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:32:22,124 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:32:22,124 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:32:26,672 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:32:31,054 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:32:31,054 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:32:32,250 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:32:33,522 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:32:33,522 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:32:33,523 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:32:33,523 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:32:34,127 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:32:34,127 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:32:37,524 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:32:42,525 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:32:45,323 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:32:45,324 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:32:45,324 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:32:45,324 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:32:46,054 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:32:46,054 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:32:46,130 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:32:46,130 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:32:48,289 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:32:49,679 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:32:53,680 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:32:57,226 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:32:57,227 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:32:57,227 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:32:57,227 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:32:58,132 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:32:58,133 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:32:59,227 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:33:01,054 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:33:01,054 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:33:04,267 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:33:09,058 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:33:09,058 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:33:09,059 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:33:09,059 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:33:09,135 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:33:10,059 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:33:10,136 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:33:15,060 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:33:16,054 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:33:16,054 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:33:19,679 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:33:20,680 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:33:20,906 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:33:20,906 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:33:20,907 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:33:20,907 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:33:21,138 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:33:22,139 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:33:25,908 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:33:30,909 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:33:31,054 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:33:31,054 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:33:32,750 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:33:32,750 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:33:32,751 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:33:32,751 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:33:33,141 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:33:34,141 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:33:36,751 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:33:41,752 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:33:44,549 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:33:44,549 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:33:44,550 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:33:44,550 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:33:45,144 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:33:46,054 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:33:46,055 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:33:46,144 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:33:47,229 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:33:49,680 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:33:52,680 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:33:56,434 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:33:56,434 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:33:56,435 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:33:56,435 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:33:57,147 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:33:58,147 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:33:58,435 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:34:01,054 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:34:01,055 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:34:04,285 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:34:08,210 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:34:08,211 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:34:08,211 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:34:08,212 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:34:09,150 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:34:10,150 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:34:10,212 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:34:15,213 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:34:16,054 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:34:16,055 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:34:19,680 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:34:20,090 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:34:20,091 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:34:20,091 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:34:20,091 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:34:20,153 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:34:21,091 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:34:22,153 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:34:26,092 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:34:31,055 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:34:31,055 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:34:31,217 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:34:31,918 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:34:31,918 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:34:31,919 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:34:31,919 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:34:32,156 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:34:34,156 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:34:36,920 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:34:41,920 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:34:43,710 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:34:43,710 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:34:43,710 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:34:43,711 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:34:44,159 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:34:44,159 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:34:46,055 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:34:46,055 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:34:47,235 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:34:49,681 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:34:52,681 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:34:55,566 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:34:55,566 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:34:55,567 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:34:55,567 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:34:56,162 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:34:56,162 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:34:58,567 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:35:01,055 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:35:01,055 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:35:04,199 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:35:07,394 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:35:07,394 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:35:07,395 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:35:07,395 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:35:08,165 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:35:08,165 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:35:09,395 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:35:14,396 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:35:16,055 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:35:16,055 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:35:19,210 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:35:19,210 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:35:19,211 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:35:19,211 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:35:19,681 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:35:19,681 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:35:20,167 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:35:20,168 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:35:24,682 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:35:29,683 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:35:31,055 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:35:31,055 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:35:31,114 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:35:31,286 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:35:31,286 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:35:31,287 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:35:32,170 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:35:32,171 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:35:35,287 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:35:40,288 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:35:42,897 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:35:42,897 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:35:42,898 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:35:42,898 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:35:43,173 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:35:44,173 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:35:45,898 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:35:46,055 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:35:46,055 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:35:49,682 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:35:51,682 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:35:54,770 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:35:54,770 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:35:54,771 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:35:54,771 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:35:55,176 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:35:56,176 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:35:56,771 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:36:01,055 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:36:01,056 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:36:02,274 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:36:06,594 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:36:06,594 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:36:06,595 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:36:06,595 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:36:07,179 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:36:07,595 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:36:08,179 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:36:12,596 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:36:16,055 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:36:16,056 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:36:18,231 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:36:18,422 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:36:18,422 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:36:18,423 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:36:18,423 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:36:19,182 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:36:19,682 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:36:20,182 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:36:23,683 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:36:28,684 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:36:30,230 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:36:30,231 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:36:30,231 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:36:30,231 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:36:31,055 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:36:31,056 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:36:31,185 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:36:32,185 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:36:34,272 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:36:39,272 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:36:42,082 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:36:42,082 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:36:42,083 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:36:42,083 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:36:42,187 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:36:44,188 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:36:45,083 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:36:46,056 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:36:46,056 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:36:49,683 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:36:50,683 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:36:53,950 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:36:53,951 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:36:53,951 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:36:53,951 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:36:54,191 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:36:54,191 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:36:55,951 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:37:00,952 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:37:01,056 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:37:01,056 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:37:05,786 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:37:05,842 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:37:05,843 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:37:05,843 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:37:06,193 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:37:06,194 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:37:06,843 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:37:11,844 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:37:16,056 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:37:16,056 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:37:17,229 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:37:17,634 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:37:17,634 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:37:17,635 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:37:17,635 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:37:18,196 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:37:18,197 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:37:19,683 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:37:22,684 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:37:27,685 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:37:29,441 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:37:29,442 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:37:29,442 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:37:29,442 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:37:30,199 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:37:30,200 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:37:31,056 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:37:31,056 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:37:33,286 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:37:38,287 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:37:41,330 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:37:41,331 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:37:41,331 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:37:41,331 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:37:42,202 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:37:42,203 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:37:43,331 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:37:46,056 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:37:46,056 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:37:49,235 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:37:49,684 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:37:53,178 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:37:53,179 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:37:53,179 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:37:53,179 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:37:53,205 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:37:54,205 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:37:55,179 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:38:00,180 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:38:01,056 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:38:01,056 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:38:04,982 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:38:04,982 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:38:04,983 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:38:04,983 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:38:05,208 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:38:05,983 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:38:06,208 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:38:10,984 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:38:15,985 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:38:16,056 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:38:16,056 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:38:16,830 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:38:16,830 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:38:16,831 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:38:16,831 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:38:17,211 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:38:18,211 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:38:19,684 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:38:21,685 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:38:26,686 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:38:28,656 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:38:28,657 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:38:28,657 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:38:28,657 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:38:29,214 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:38:30,214 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:38:31,056 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:38:31,057 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:38:32,281 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:38:37,282 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:38:40,530 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:38:40,530 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:38:40,531 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:38:40,531 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:38:41,217 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:38:42,217 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:38:42,531 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:38:46,056 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:38:46,057 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:38:48,279 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:38:49,685 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:38:52,370 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:38:52,370 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:38:52,371 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:38:52,371 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:38:53,220 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:38:53,371 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:38:54,220 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:38:58,372 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:39:01,057 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:39:01,057 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:39:04,166 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:39:04,206 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:39:04,206 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:39:04,207 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:39:04,207 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:39:04,223 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:39:06,223 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:39:09,208 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:39:14,208 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:39:15,989 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:39:15,990 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:39:15,990 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:39:15,990 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:39:16,057 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:39:16,057 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:39:16,225 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:39:16,226 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:39:19,278 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:39:19,685 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:39:24,686 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:39:27,810 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:39:27,810 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:39:27,811 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:39:27,811 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:39:28,228 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:39:28,229 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:39:29,811 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:39:31,057 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:39:31,057 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:39:35,287 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:39:39,638 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:39:39,639 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:39:39,640 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:39:39,640 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:39:40,231 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:39:40,640 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:39:41,232 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:39:45,641 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:39:46,057 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:39:46,057 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:39:49,686 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:39:50,686 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:39:51,462 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:39:51,463 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:39:51,463 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:39:51,463 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:39:52,234 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:39:53,235 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:39:56,464 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:40:01,057 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:40:01,057 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:40:02,291 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:40:03,295 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:40:03,295 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:40:03,296 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:40:03,296 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:40:04,237 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:40:05,237 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:40:07,296 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:40:12,297 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:40:15,143 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:40:15,144 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:40:15,144 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:40:15,144 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:40:15,240 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:40:16,057 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:40:16,057 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:40:17,241 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:40:18,284 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:40:19,686 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:40:23,687 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:40:27,050 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:40:27,051 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:40:27,051 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:40:27,051 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:40:27,243 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:40:29,051 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:40:29,244 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:40:31,057 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:40:31,058 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:40:34,218 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:40:38,894 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:40:38,894 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:40:38,895 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:40:38,895 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:40:39,246 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:40:39,895 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:40:41,247 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:40:44,896 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:40:46,057 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:40:46,058 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:40:49,687 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:40:50,686 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:40:50,726 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:40:50,726 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:40:50,727 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:40:50,727 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:40:51,249 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:40:53,250 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:40:55,728 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:41:00,728 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:41:01,058 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:41:01,058 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:41:02,546 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:41:02,546 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:41:02,547 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:41:02,547 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:41:03,252 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:41:05,253 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:41:06,548 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:41:11,548 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:41:14,332 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:41:14,333 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:41:14,333 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:41:14,333 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:41:15,255 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:41:16,058 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:41:16,058 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:41:17,252 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:41:17,256 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:41:19,687 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:41:22,688 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:41:26,194 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:41:26,194 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:41:26,195 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:41:26,195 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:41:26,258 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:41:27,258 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:41:28,196 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:41:31,058 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:41:31,058 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:41:33,216 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:41:38,010 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:41:38,010 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:41:38,011 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:41:38,011 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:41:38,261 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:41:39,011 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:41:39,261 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:41:44,012 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:41:46,058 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:41:46,058 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:41:49,196 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:41:49,688 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:41:49,846 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:41:49,851 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:41:49,851 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:41:49,851 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:41:50,264 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:41:51,265 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:41:54,852 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:41:59,852 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:42:01,058 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:42:01,058 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:42:01,686 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:42:01,686 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:42:01,687 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:42:01,687 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:42:02,268 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:42:03,268 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:42:05,688 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:42:10,688 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:42:13,500 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:42:13,501 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:42:13,501 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:42:13,502 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:42:14,271 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:42:15,271 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:42:16,058 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:42:16,058 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:42:16,059 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:42:19,688 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:42:21,689 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:42:25,378 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:42:25,379 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:42:25,379 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:42:25,379 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:42:26,274 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:42:27,275 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:42:27,380 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:42:31,058 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:42:31,059 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:42:33,292 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:42:37,202 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:42:37,203 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:42:37,203 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:42:37,203 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:42:37,277 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:42:39,204 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:42:39,278 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:42:44,204 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:42:46,058 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:42:46,059 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:42:49,054 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:42:49,055 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:42:49,055 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:42:49,055 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:42:49,280 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:42:49,689 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:42:49,689 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:42:51,281 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:42:54,690 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:42:59,690 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:43:00,843 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:43:00,844 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:43:00,845 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:43:00,845 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:43:01,059 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:43:01,059 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:43:01,284 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:43:03,284 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:43:05,253 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:43:10,254 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:43:15,255 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:43:16,059 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:43:16,059 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:43:17,288 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:43:19,689 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:43:20,690 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:43:25,690 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:43:27,376 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:43:27,377 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:43:27,377 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:43:27,455 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:43:28,291 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:43:29,291 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:43:31,059 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:43:31,059 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:43:31,059 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:43:36,255 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:43:39,206 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:43:39,207 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:43:39,207 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:43:39,207 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:43:39,293 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:43:41,294 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:43:42,208 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:43:46,059 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:43:46,059 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:43:47,279 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:43:49,690 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:43:51,002 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:43:51,002 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:43:51,003 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:43:51,003 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:43:51,296 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:43:53,003 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:43:53,297 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:43:58,004 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:44:01,059 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:44:01,059 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:44:02,786 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:44:02,787 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:44:02,787 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:44:02,787 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:44:03,300 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:44:03,788 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:44:05,300 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:44:08,788 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:44:13,789 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:44:14,640 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:44:14,640 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:44:14,640 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:44:14,641 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:44:15,302 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:44:16,059 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:44:16,059 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:44:17,303 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:44:19,282 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:44:19,690 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:44:24,691 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:44:26,466 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:44:26,467 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:44:26,467 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:44:26,467 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:44:27,305 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:44:29,306 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:44:30,468 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:44:31,059 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:44:31,060 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:44:36,287 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:44:38,366 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:44:38,366 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:44:38,367 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:44:38,367 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:44:39,308 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:44:39,309 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:44:41,367 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:44:46,059 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:44:46,060 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:44:47,261 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:44:49,691 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:44:50,165 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:44:50,165 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:44:50,166 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:44:50,166 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:44:50,311 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:44:51,312 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:44:53,166 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:44:58,167 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:45:01,060 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:45:01,060 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:45:02,054 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:45:02,055 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:45:02,055 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:45:02,055 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:45:02,315 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:45:03,315 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:45:04,055 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:45:09,056 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:45:13,848 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:45:13,849 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:45:13,849 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:45:13,849 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:45:14,318 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:45:14,850 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:45:15,318 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:45:16,060 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:45:16,060 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:45:19,691 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:45:20,692 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:45:25,692 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:45:25,716 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:45:25,716 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:45:25,716 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:45:25,717 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:45:26,321 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:45:27,321 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:45:30,717 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:45:31,060 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:45:31,060 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:45:36,260 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:45:37,560 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:45:37,560 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:45:37,560 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:45:37,561 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:45:38,324 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:45:39,325 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:45:41,561 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:45:46,060 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:45:46,060 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:45:47,273 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:45:49,446 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:45:49,446 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:45:49,447 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:45:49,447 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:45:49,692 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:45:50,327 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:45:51,327 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:45:52,692 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:45:57,693 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:46:01,060 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:46:01,060 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:46:01,274 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:46:01,274 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:46:01,275 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:46:01,275 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:46:01,330 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:46:03,275 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:46:03,330 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:46:08,276 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:46:13,072 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:46:13,072 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:46:13,072 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:46:13,073 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:46:13,333 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:46:14,073 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:46:15,334 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:46:16,060 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:46:16,060 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:46:19,237 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:46:19,692 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:46:24,693 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:46:24,918 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:46:24,919 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:46:24,919 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:46:24,919 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:46:25,336 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:46:27,337 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:46:29,920 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:46:31,060 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:46:31,060 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:46:35,267 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:46:36,775 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:46:36,775 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:46:36,775 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:46:36,776 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:46:37,339 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:46:39,340 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:46:40,776 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:46:45,777 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:46:46,060 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:46:46,061 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:46:48,617 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:46:48,618 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:46:48,618 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:46:48,618 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:46:49,342 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:46:49,342 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:46:49,693 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:46:51,693 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:46:56,694 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:47:00,458 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:47:00,462 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:47:00,462 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:47:00,462 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:47:01,061 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:47:01,061 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:47:01,345 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:47:01,345 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:47:02,268 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:47:07,268 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:47:12,269 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:47:12,352 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:47:12,352 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:47:12,353 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:47:12,353 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:47:13,348 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:47:13,348 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:47:16,061 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:47:16,061 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:47:18,217 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:47:19,693 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:47:23,694 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:47:24,210 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:47:24,210 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:47:24,210 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:47:24,211 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:47:24,350 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:47:25,351 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:47:29,211 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:47:31,061 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:47:31,061 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:47:34,212 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:47:36,082 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:47:36,083 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:47:36,083 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:47:36,083 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:47:36,353 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:47:37,354 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:47:40,084 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:47:45,084 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:47:46,061 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:47:46,061 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:47:47,926 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:47:47,927 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:47:47,927 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:47:47,927 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:47:48,356 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:47:49,357 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:47:49,694 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:47:50,694 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:47:55,695 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:47:59,781 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:47:59,782 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:47:59,782 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:47:59,782 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:48:00,359 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:48:00,783 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:48:01,061 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:48:01,061 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:48:01,359 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:48:06,226 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:48:11,226 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:48:11,636 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:48:11,636 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:48:11,636 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:48:11,637 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:48:12,362 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:48:13,362 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:48:16,061 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:48:16,061 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:48:17,212 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:48:19,694 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:48:22,695 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:48:23,480 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:48:23,481 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:48:23,481 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:48:23,481 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:48:24,365 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:48:25,365 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:48:28,482 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:48:31,061 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:48:31,061 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:48:34,204 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:48:35,371 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:48:35,371 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:48:35,371 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:48:35,372 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:48:36,368 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:48:37,368 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:48:39,372 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:48:44,373 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:48:49,373 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:48:49,695 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:48:50,407 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:48:50,407 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:48:54,593 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:48:58,750 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:48:58,750 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:48:58,751 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:48:58,751 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:48:59,373 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:48:59,373 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:48:59,751 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:49:04,752 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:49:05,406 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:49:05,407 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:49:10,472 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:49:10,472 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:49:10,473 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:49:10,473 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:49:10,473 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:49:11,376 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:49:11,376 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:49:15,474 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:49:19,695 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:49:20,406 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:49:20,407 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:49:20,546 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:49:22,293 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:49:22,293 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:49:22,293 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:49:22,294 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:49:22,378 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:49:23,379 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:49:26,294 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:49:31,295 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:49:34,126 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:49:34,126 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:49:34,126 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:49:34,127 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:49:34,381 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:49:35,382 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:49:35,407 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:49:35,407 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:49:36,556 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:49:41,557 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:49:45,972 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:49:45,972 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:49:45,973 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:49:45,973 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:49:46,384 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:49:46,973 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:49:47,385 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:49:49,696 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:49:50,407 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:49:50,407 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:49:52,611 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:49:57,612 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:49:57,807 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:49:57,807 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:49:57,807 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:49:57,808 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:49:58,387 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:49:59,388 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:50:02,808 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:50:05,407 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:50:05,407 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:50:08,627 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:50:09,637 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:50:09,638 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:50:09,638 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:50:09,638 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:50:10,391 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:50:11,391 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:50:13,639 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:50:18,640 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:50:19,696 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:50:20,407 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:50:20,407 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:50:21,485 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:50:21,485 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:50:21,486 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:50:21,486 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:50:22,394 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:50:23,394 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:50:24,486 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:50:29,487 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:50:33,336 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:50:33,336 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:50:33,336 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:50:33,337 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:50:33,396 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:50:35,337 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:50:35,397 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:50:35,407 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:50:35,407 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:50:40,544 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:50:45,205 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:50:45,205 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:50:45,205 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:50:45,206 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:50:45,399 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:50:46,206 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:50:47,399 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:50:49,697 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:50:50,407 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:50:50,408 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:50:51,540 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:50:56,541 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:50:57,044 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:50:57,044 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:50:57,044 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:50:57,045 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:50:57,402 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:50:59,403 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:51:02,045 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:51:05,407 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:51:05,408 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:51:07,619 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:51:08,901 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:51:08,901 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:51:08,902 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:51:08,902 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:51:09,405 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:51:09,405 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:51:12,903 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:51:17,903 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:51:19,697 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:51:20,408 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:51:20,408 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:51:20,750 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:51:20,751 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:51:20,751 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:51:20,751 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:51:21,409 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:51:21,410 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:51:23,752 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:51:28,752 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:51:32,606 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:51:32,607 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:51:32,607 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:51:32,607 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:51:33,413 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:51:33,413 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:51:34,608 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:51:35,408 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:51:35,408 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:51:39,609 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:51:44,442 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:51:44,443 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:51:44,443 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:51:44,443 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:51:45,415 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:51:45,416 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:51:45,444 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:51:49,698 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:51:50,408 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:51:50,408 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:51:50,596 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:51:55,596 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:51:56,324 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:51:56,328 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:51:56,328 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:51:56,329 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:51:56,418 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:51:57,418 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:52:01,329 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:52:05,408 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:52:05,408 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:52:06,538 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:52:08,162 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:52:08,162 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:52:08,162 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:52:08,163 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:52:08,421 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:52:09,421 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:52:12,163 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:52:17,164 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:52:19,698 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:52:20,053 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:52:20,054 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:52:20,054 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:52:20,054 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:52:20,408 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:52:20,408 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:52:20,424 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:52:21,425 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:52:22,601 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:52:27,602 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:52:31,909 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:52:31,910 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:52:31,910 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:52:31,910 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:52:32,428 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:52:32,911 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:52:33,428 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:52:35,408 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:52:35,409 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:52:38,603 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:52:43,603 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:52:43,759 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:52:43,760 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:52:43,760 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:52:43,760 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:52:44,431 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:52:45,431 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:52:48,761 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:52:49,699 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:52:50,408 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:52:50,409 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:52:54,604 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:52:55,623 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:52:55,624 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:52:55,624 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:52:55,624 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:52:56,434 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:52:57,434 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:52:59,625 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:53:04,626 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:53:05,408 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:53:05,409 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:53:07,461 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:53:07,462 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:53:07,462 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:53:07,463 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:53:08,437 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:53:09,438 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:53:10,463 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:53:15,464 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:53:19,303 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:53:19,303 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:53:19,304 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:53:19,304 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:53:19,440 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:53:19,699 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:53:20,409 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:53:20,409 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:53:20,552 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:53:21,441 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:53:25,552 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:53:30,553 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:53:31,163 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:53:31,164 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:53:31,164 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:53:31,164 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:53:31,443 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:53:33,444 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:53:35,409 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:53:35,409 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:53:35,632 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:53:40,633 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:53:43,059 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:53:43,060 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:53:43,060 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:53:43,060 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:53:43,447 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:53:43,447 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:53:46,061 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:53:49,700 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:53:50,409 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:53:50,410 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:53:51,644 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:53:54,950 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:53:54,950 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:53:54,951 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:53:54,951 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:53:55,450 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:53:55,450 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:53:56,952 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:54:01,952 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:54:05,409 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:54:05,409 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:54:06,764 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:54:06,765 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:54:06,765 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:54:06,765 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:54:07,454 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:54:07,454 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:54:07,766 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:54:12,766 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:54:17,767 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:54:18,607 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:54:18,608 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:54:18,608 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:54:18,608 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:54:19,457 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:54:19,457 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:54:19,700 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:54:20,409 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:54:20,410 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:54:23,644 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:54:28,644 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:54:30,453 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:54:30,454 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:54:30,454 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:54:30,454 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:54:30,460 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:54:31,461 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:54:34,455 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:54:35,409 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:54:35,410 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:54:39,641 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:54:42,267 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:54:42,268 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:54:42,268 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:54:42,268 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:54:42,463 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:54:43,464 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:54:45,269 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:54:49,701 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:54:50,410 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:54:50,410 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:54:50,591 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:54:54,122 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:54:54,122 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:54:54,123 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:54:54,123 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:54:54,467 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:54:55,467 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:54:56,123 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:55:01,124 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:55:05,410 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:55:05,410 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:55:05,964 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:55:05,964 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:55:05,964 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:55:05,965 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:55:06,470 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:55:06,965 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:55:07,471 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:55:11,966 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:55:16,966 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:55:17,805 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:55:17,805 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:55:17,806 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:55:17,806 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:55:18,473 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:55:19,474 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:55:19,701 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:55:20,410 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:55:20,410 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:55:22,609 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:55:27,610 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:55:29,670 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:55:29,671 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:55:29,671 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:55:29,671 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:55:30,477 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:55:31,477 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:55:32,672 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:55:35,410 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:55:35,410 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:55:38,613 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:55:41,491 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:55:41,492 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:55:41,492 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:55:41,492 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:55:42,480 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:55:43,480 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:55:44,493 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:55:49,493 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:55:49,702 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:55:50,410 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:55:50,411 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:55:53,370 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:55:53,371 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:55:53,371 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:55:53,371 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:55:53,483 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:55:55,371 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:55:55,483 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:56:00,372 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:56:05,165 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:56:05,165 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:56:05,165 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:56:05,166 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:56:05,410 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:56:05,411 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:56:05,486 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:56:05,486 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:56:05,600 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:56:10,601 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:56:15,602 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:56:16,993 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:56:16,993 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:56:16,993 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:56:16,994 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:56:17,489 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:56:17,489 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:56:19,702 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:56:20,410 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:56:20,411 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:56:21,579 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:56:26,580 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:56:28,894 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:56:28,894 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:56:28,895 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:56:28,895 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:56:29,492 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:56:29,492 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:56:31,895 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:56:35,411 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:56:35,411 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:56:37,598 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:56:40,679 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:56:40,680 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:56:40,680 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:56:40,680 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:56:41,495 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:56:41,495 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:56:42,681 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:56:47,682 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:56:49,703 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:56:50,411 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:56:50,411 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:56:52,527 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:56:52,536 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:56:52,536 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:56:52,537 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:56:53,498 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:56:53,499 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:56:53,537 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:56:58,538 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:57:03,539 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:57:04,361 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:57:04,361 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:57:04,362 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:57:04,362 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:57:04,501 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:57:05,411 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:57:05,411 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:57:05,501 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:57:08,603 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:57:13,604 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:57:16,206 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:57:16,206 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:57:16,206 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:57:16,207 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:57:16,504 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:57:17,505 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:57:19,207 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:57:19,703 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:57:20,411 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:57:20,412 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:57:24,618 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:57:28,082 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:57:28,082 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:57:28,083 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:57:28,083 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:57:28,508 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:57:29,508 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:57:30,084 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:57:35,084 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:57:35,411 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:57:35,411 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:57:39,877 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:57:39,878 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:57:39,878 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:57:39,879 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:57:40,511 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:57:40,879 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:57:41,512 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:57:45,880 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:57:49,704 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:57:50,411 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:57:50,411 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:57:51,630 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:57:51,712 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:57:51,713 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:57:51,713 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:57:51,713 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:57:52,515 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:57:54,515 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:57:56,714 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:58:01,715 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:58:03,566 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:58:03,566 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:58:03,567 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:58:03,567 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:58:04,518 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:58:05,411 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:58:05,412 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:58:06,518 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:58:07,582 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:58:12,583 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:58:15,434 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:58:15,435 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:58:15,435 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:58:15,435 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:58:15,520 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:58:18,436 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:58:18,521 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:58:19,704 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:58:20,412 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:58:20,412 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:58:23,632 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:58:27,266 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:58:27,267 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:58:27,267 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:58:27,267 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:58:27,523 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:58:28,524 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:58:29,268 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:58:34,269 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:58:35,411 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:58:35,412 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:58:39,134 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:58:39,134 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:58:39,134 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:58:39,135 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:58:39,526 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:58:40,135 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:58:40,527 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:58:45,136 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:58:49,705 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:58:50,412 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:58:50,412 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:58:50,587 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:58:50,968 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:58:50,969 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:58:50,969 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:58:50,969 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:58:51,529 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:58:52,530 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:58:55,970 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:59:00,971 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:59:02,814 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:59:02,815 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:59:02,815 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:59:02,815 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:59:03,532 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:59:04,533 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:59:05,412 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:59:05,412 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:59:06,554 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:59:11,554 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:59:14,699 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:59:14,699 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:59:14,699 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:59:14,700 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:59:15,535 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:59:16,536 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:59:16,700 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:59:19,705 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:59:20,412 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:59:20,412 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:59:22,617 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:59:26,542 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:59:26,542 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:59:26,542 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:59:26,543 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:59:27,538 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:59:28,539 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:59:28,543 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:59:33,544 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:59:35,412 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:59:35,412 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:59:38,375 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:59:38,375 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:59:38,376 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:59:38,376 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:59:38,541 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:59:39,376 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:59:40,542 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:59:44,377 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:59:49,378 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:59:49,706 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 00:59:50,178 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 00:59:50,179 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 00:59:50,179 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 00:59:50,179 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 00:59:50,412 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 00:59:50,412 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 00:59:50,544 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 00:59:52,545 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 00:59:54,658 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 00:59:59,658 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:00:02,039 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:00:02,040 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:00:02,040 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:00:02,040 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:00:02,548 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:00:04,548 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:00:05,041 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:00:05,412 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:00:05,413 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:00:10,562 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:00:13,927 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:00:13,928 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:00:13,928 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:00:13,929 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:00:14,551 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:00:15,929 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:00:16,552 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:00:19,707 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:00:20,412 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:00:20,413 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:00:21,606 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:00:25,770 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:00:25,771 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:00:25,771 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:00:25,771 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:00:26,554 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:00:26,771 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:00:28,555 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:00:31,772 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:00:35,412 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:00:35,413 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:00:37,578 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:00:37,631 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:00:37,631 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:00:37,632 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:00:37,632 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:00:38,558 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:00:40,558 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:00:42,633 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:00:47,633 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:00:49,471 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:00:49,471 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:00:49,471 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:00:49,472 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:00:49,561 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:00:49,707 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:00:50,413 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:00:50,413 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:00:50,561 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:00:53,617 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:00:58,617 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:01:01,325 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:01:01,325 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:01:01,325 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:01:01,326 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:01:01,564 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:01:02,565 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:01:04,326 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:01:05,413 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:01:05,413 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:01:09,577 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:01:13,180 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:01:13,181 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:01:13,181 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:01:13,181 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:01:13,568 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:01:14,568 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:01:15,182 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:01:19,708 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:01:20,413 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:01:20,413 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:01:20,631 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:01:25,020 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:01:25,020 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:01:25,021 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:01:25,021 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:01:25,571 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:01:26,021 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:01:26,571 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:01:31,022 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:01:35,413 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:01:35,413 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:01:36,594 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:01:36,882 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:01:36,883 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:01:36,883 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:01:36,883 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:01:37,574 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:01:38,574 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:01:41,884 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:01:46,884 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:01:48,764 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:01:48,765 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:01:48,765 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:01:48,765 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:01:49,577 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:01:49,712 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:01:50,413 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:01:50,414 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:01:50,577 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:01:52,571 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:01:57,572 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:02:00,597 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:02:00,597 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:02:00,598 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:02:00,598 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:02:01,580 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:02:02,580 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:02:02,598 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:02:05,413 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:02:05,414 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:02:07,624 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:02:12,439 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:02:12,440 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:02:12,440 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:02:12,440 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:02:12,583 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:02:13,441 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:02:14,583 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:02:18,441 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:02:19,709 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:02:20,413 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:02:20,414 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:02:23,557 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:02:24,297 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:02:24,297 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:02:24,297 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:02:24,298 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:02:24,586 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:02:26,587 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:02:29,299 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:02:34,300 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:02:35,413 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:02:35,414 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:02:36,110 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:02:36,111 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:02:36,111 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:02:36,111 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:02:36,589 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:02:38,590 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:02:40,112 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:02:45,112 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:02:47,950 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:02:47,951 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:02:47,951 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:02:47,951 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:02:48,592 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:02:49,709 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:02:50,414 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:02:50,414 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:02:50,535 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:02:50,593 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:02:55,536 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:02:59,853 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:02:59,853 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:02:59,853 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:02:59,855 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:03:00,595 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:03:00,855 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:03:02,596 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:03:05,414 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:03:05,414 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:03:06,622 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:03:11,623 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:03:11,683 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:03:11,684 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:03:11,684 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:03:11,684 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:03:12,599 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:03:12,599 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:03:16,685 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:03:19,710 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:03:21,710 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:03:26,277 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:03:26,278 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:03:27,419 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:03:28,604 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:03:32,420 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:03:37,421 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:03:38,022 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:03:38,022 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:03:38,023 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:03:38,043 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:03:38,606 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:03:40,607 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:03:41,276 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:03:41,276 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:03:42,476 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:03:47,476 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:03:49,710 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:03:49,810 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:03:49,810 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:03:49,811 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:03:49,811 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:03:50,610 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:03:50,610 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:03:52,811 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:03:56,276 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:03:56,277 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:03:58,417 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:04:01,610 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:04:01,610 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:04:01,611 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:04:01,611 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:04:01,613 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:04:02,613 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:04:03,611 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:04:08,612 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:04:11,276 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:04:11,277 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:04:13,450 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:04:13,450 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:04:13,451 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:04:13,452 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:04:13,615 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:04:14,452 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:04:14,616 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:04:19,452 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:04:19,711 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:04:24,711 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:04:25,239 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:04:25,240 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:04:25,240 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:04:25,240 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:04:25,619 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:04:26,276 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:04:26,277 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:04:26,619 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:04:30,493 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:04:35,494 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:04:37,094 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:04:37,094 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:04:37,095 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:04:37,095 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:04:37,622 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:04:38,622 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:04:41,095 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:04:41,276 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:04:41,277 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:04:46,416 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:04:48,966 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:04:48,966 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:04:48,967 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:04:48,968 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:04:49,625 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:04:49,711 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:04:50,626 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:04:51,712 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:04:56,277 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:04:56,277 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:04:57,451 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:05:00,806 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:05:00,806 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:05:00,807 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:05:00,807 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:05:01,629 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:05:02,629 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:05:02,807 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:05:07,808 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:05:11,277 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:05:11,277 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:05:12,662 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:05:12,662 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:05:12,663 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:05:12,663 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:05:13,632 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:05:13,663 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:05:14,633 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:05:18,664 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:05:19,712 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:05:23,712 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:05:24,459 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:05:24,460 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:05:24,460 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:05:24,460 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:05:24,635 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:05:26,277 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:05:26,277 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:05:26,636 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:05:29,478 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:05:34,478 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:05:36,342 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:05:36,342 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:05:36,343 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:05:36,343 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:05:36,638 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:05:38,639 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:05:40,343 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:05:41,277 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:05:41,277 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:05:45,492 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:05:48,182 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:05:48,183 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:05:48,183 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:05:48,183 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:05:48,641 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:05:49,712 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:05:50,642 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:05:50,713 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:05:55,713 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:05:56,277 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:05:56,277 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:06:00,074 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:06:00,074 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:06:00,075 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:06:00,075 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:06:00,644 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:06:01,075 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:06:02,645 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:06:06,076 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:06:11,077 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:06:11,277 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:06:11,278 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:06:11,926 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:06:11,926 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:06:11,927 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:06:11,927 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:06:12,648 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:06:12,648 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:06:16,928 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:06:19,713 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:06:22,713 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:06:23,735 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:06:23,736 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:06:23,736 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:06:23,736 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:06:24,651 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:06:24,651 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:06:26,277 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:06:26,278 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:06:28,423 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:06:33,424 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:06:35,626 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:06:35,626 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:06:35,627 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:06:35,627 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:06:35,654 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:06:36,654 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:06:38,627 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:06:41,278 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:06:41,278 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:06:44,420 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:06:47,518 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:06:47,518 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:06:47,519 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:06:47,519 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:06:47,656 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:06:48,657 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:06:49,519 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:06:49,717 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:06:54,718 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:06:56,278 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:06:56,278 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:06:59,378 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:06:59,378 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:06:59,379 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:06:59,379 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:06:59,659 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:07:00,379 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:07:00,660 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:07:05,380 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:07:10,380 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:07:11,189 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:07:11,189 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:07:11,189 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:07:11,189 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:07:11,278 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:07:11,278 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:07:11,662 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:07:12,663 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:07:15,493 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:07:19,714 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:07:20,714 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:07:23,055 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:07:23,056 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:07:23,056 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:07:23,057 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:07:23,666 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:07:24,666 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:07:26,058 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:07:26,278 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:07:26,278 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:07:31,492 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:07:34,958 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:07:34,959 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:07:34,959 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:07:34,959 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:07:35,669 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:07:36,669 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:07:36,960 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:07:41,278 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:07:41,279 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:07:42,405 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:07:46,822 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:07:46,822 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:07:46,823 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:07:46,823 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:07:47,672 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:07:47,823 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:07:48,672 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:07:49,714 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:07:53,715 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:07:56,278 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:07:56,279 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:07:58,678 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:07:58,678 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:07:58,679 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:07:58,680 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:07:59,674 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:07:59,680 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:08:00,675 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:08:04,681 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:08:09,681 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:08:10,525 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:08:10,526 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:08:10,526 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:08:10,526 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:08:10,677 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:08:11,278 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:08:11,279 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:08:12,678 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:08:15,510 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:08:19,715 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:08:20,715 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:08:22,446 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:08:22,446 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:08:22,447 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:08:22,447 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:08:22,680 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:08:24,680 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:08:26,278 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:08:26,279 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:08:26,279 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:08:31,512 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:08:34,326 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:08:34,326 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:08:34,327 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:08:34,328 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:08:34,683 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:08:36,683 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:08:37,328 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:08:41,278 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:08:41,279 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:08:42,476 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:08:46,198 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:08:46,198 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:08:46,199 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:08:46,199 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:08:46,685 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:08:48,199 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:08:48,686 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:08:49,715 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:08:53,716 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:08:56,278 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:08:56,279 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:08:58,086 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:08:58,086 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:08:58,087 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:08:58,087 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:08:58,688 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:08:58,688 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:08:59,087 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:09:04,088 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:09:09,089 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:09:09,917 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:09:09,917 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:09:09,918 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:09:09,919 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:09:10,691 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:09:10,691 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:09:11,279 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:09:11,279 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:09:14,490 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:09:19,491 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:09:19,715 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:09:21,822 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:09:21,823 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:09:21,823 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:09:21,823 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:09:22,694 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:09:22,694 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:09:24,824 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:09:26,279 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:09:26,279 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:09:30,412 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:09:33,674 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:09:33,674 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:09:33,675 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:09:33,675 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:09:33,696 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:09:34,696 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:09:35,675 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:09:40,676 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:09:41,279 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:09:41,279 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:09:45,518 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:09:45,518 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:09:45,519 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:09:45,520 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:09:45,699 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:09:46,520 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:09:46,699 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:09:49,716 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:09:51,717 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:09:56,279 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:09:56,280 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:09:57,324 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:09:57,366 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:09:57,366 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:09:57,367 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:09:57,367 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:09:57,702 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:09:58,702 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:10:02,368 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:10:07,368 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:10:09,143 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:10:09,144 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:10:09,144 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:10:09,144 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:10:09,705 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:10:10,705 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:10:11,279 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:10:11,280 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:10:12,491 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:10:17,491 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:10:19,717 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:10:21,014 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:10:21,015 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:10:21,015 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:10:21,015 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:10:21,708 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:10:22,708 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:10:23,016 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:10:26,279 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:10:26,280 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:10:28,439 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:10:32,866 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:10:32,867 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:10:32,867 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:10:32,867 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:10:33,711 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:10:33,868 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:10:34,711 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:10:38,868 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:10:41,279 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:10:41,280 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:10:44,464 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:10:44,698 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:10:44,699 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:10:44,699 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:10:44,699 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:10:44,713 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:10:46,714 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:10:49,700 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:10:49,717 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:10:54,718 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:10:56,279 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:10:56,280 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:10:56,538 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:10:56,538 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:10:56,539 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:10:56,539 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:10:56,716 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:10:58,717 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:11:00,540 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:11:05,540 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:11:08,365 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:11:08,366 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:11:08,366 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:11:08,366 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:11:08,719 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:11:10,720 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:11:11,279 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:11:11,280 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:11:11,280 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:11:16,482 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:11:19,717 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:11:20,238 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:11:20,238 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:11:20,239 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:11:20,239 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:11:20,723 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:11:20,723 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:11:22,239 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:11:26,280 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:11:26,280 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:11:27,428 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:11:32,078 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:11:32,078 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:11:32,079 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:11:32,079 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:11:32,726 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:11:32,726 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:11:33,079 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:11:38,080 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:11:41,280 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:11:41,280 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:11:43,449 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:11:43,930 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:11:43,934 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:11:43,935 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:11:43,935 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:11:44,729 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:11:44,730 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:11:48,935 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:11:49,718 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:11:54,719 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:11:55,730 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:11:55,731 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:11:55,731 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:11:55,731 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:11:55,732 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:11:56,280 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:11:56,280 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:11:56,733 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:12:00,446 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:12:05,447 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:12:07,602 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:12:07,602 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:12:07,603 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:12:07,603 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:12:07,735 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:12:08,736 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:12:10,603 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:12:11,280 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:12:11,281 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:12:16,434 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:12:19,430 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:12:19,431 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:12:19,431 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:12:19,431 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:12:19,718 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:12:19,738 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:12:20,738 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:12:21,719 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:12:26,280 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:12:26,281 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:12:27,511 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:12:31,282 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:12:31,282 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:12:31,283 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:12:31,283 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:12:31,741 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:12:32,741 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:12:33,283 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:12:38,284 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:12:41,280 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:12:41,281 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:12:43,098 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:12:43,098 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:12:43,099 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:12:43,099 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:12:43,743 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:12:44,099 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:12:44,744 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:12:49,100 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:12:49,719 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:12:54,720 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:12:54,891 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:12:54,892 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:12:54,892 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:12:54,892 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:12:55,746 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:12:56,280 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:12:56,281 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:12:56,746 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:13:00,481 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:13:05,482 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:13:10,482 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:13:11,281 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:13:11,281 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:13:16,428 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:13:18,299 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:13:18,300 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:13:18,300 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:13:18,300 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:13:18,751 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:13:18,751 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:13:19,719 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:13:21,720 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:13:26,281 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:13:26,281 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:13:27,498 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:13:30,150 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:13:30,151 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:13:30,151 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:13:30,151 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:13:30,754 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:13:30,754 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:13:33,152 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:13:38,152 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:13:41,281 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:13:41,281 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:13:41,962 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:13:41,963 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:13:41,963 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:13:41,963 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:13:42,756 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:13:42,757 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:13:43,964 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:13:48,964 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:13:49,720 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:13:53,743 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:13:53,744 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:13:53,744 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:13:53,744 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:13:53,759 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:13:54,744 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:13:54,759 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:13:56,281 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:13:56,281 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:14:00,459 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:14:05,460 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:14:05,606 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:14:05,607 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:14:05,607 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:14:05,607 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:14:05,762 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:14:06,762 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:14:10,608 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:14:11,281 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:14:11,281 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:14:16,428 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:14:17,454 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:14:17,455 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:14:17,455 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:14:17,455 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:14:17,765 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:14:18,765 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:14:19,721 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:14:21,721 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:14:26,281 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:14:26,282 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:14:27,425 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:14:29,294 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:14:29,295 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:14:29,295 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:14:29,295 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:14:29,767 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:14:30,768 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:14:33,296 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:14:38,297 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:14:41,122 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:14:41,122 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:14:41,122 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:14:41,123 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:14:41,281 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:14:41,282 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:14:41,770 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:14:42,771 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:14:43,418 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:14:48,418 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:14:49,721 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:14:53,030 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:14:53,031 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:14:53,031 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:14:53,031 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:14:53,773 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:14:54,031 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:14:54,773 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:14:56,281 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:14:56,282 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:14:59,455 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:15:04,456 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:15:04,870 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:15:04,871 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:15:04,871 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:15:04,871 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:15:05,776 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:15:06,776 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:15:09,872 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:15:11,282 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:15:11,282 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:15:15,452 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:15:16,718 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:15:16,718 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:15:16,719 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:15:16,719 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:15:16,779 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:15:18,779 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:15:19,721 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:15:20,722 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:15:25,723 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:15:26,281 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:15:26,282 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:15:28,574 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:15:28,575 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:15:28,575 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:15:28,575 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:15:28,781 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:15:28,782 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:15:31,575 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:15:36,576 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:15:40,390 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:15:40,390 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:15:40,390 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:15:40,391 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:15:40,785 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:15:40,785 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:15:41,281 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:15:41,282 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:15:42,519 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:15:47,519 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:15:49,722 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:15:52,294 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:15:52,294 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:15:52,295 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:15:52,295 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:15:52,788 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:15:53,295 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:15:53,789 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:15:56,282 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:15:56,282 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:15:58,438 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:16:03,438 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:16:04,146 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:16:04,146 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:16:04,147 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:16:04,147 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:16:04,792 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:16:05,792 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:16:09,148 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:16:11,282 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:16:11,282 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:16:14,449 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:16:15,994 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:16:15,995 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:16:15,995 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:16:15,995 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:16:16,795 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:16:17,796 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:16:19,722 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:16:19,723 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:16:24,724 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:16:26,282 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:16:26,282 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:16:27,870 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:16:27,871 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:16:27,871 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:16:27,871 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:16:28,799 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:16:29,799 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:16:29,871 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:16:34,872 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:16:39,682 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:16:39,682 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:16:39,683 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:16:39,683 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:16:39,802 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:16:40,683 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:16:41,282 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:16:41,283 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:16:41,802 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:16:46,415 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:16:49,729 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:16:51,534 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:16:51,578 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:16:51,578 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:16:51,579 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:16:51,579 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:16:51,805 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:16:53,806 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:16:56,282 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:16:56,283 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:16:57,512 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:17:02,513 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:17:03,394 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:17:03,395 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:17:03,395 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:17:03,395 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:17:03,808 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:17:05,809 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:17:08,396 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:17:11,282 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:17:11,283 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:17:13,494 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:17:15,338 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:17:15,338 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:17:15,339 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:17:15,339 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:17:15,812 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:17:17,812 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:17:19,339 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:17:19,723 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:17:24,724 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:17:26,282 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:17:26,283 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:17:27,206 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:17:27,206 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:17:27,207 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:17:27,207 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:17:27,815 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:17:29,816 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:17:30,208 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:17:35,209 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:17:39,016 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:17:39,016 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:17:39,016 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:17:39,017 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:17:39,819 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:17:41,017 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:17:41,282 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:17:41,283 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:17:41,819 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:17:46,464 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:17:49,724 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:17:50,926 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:17:50,927 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:17:50,927 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:17:50,927 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:17:51,822 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:17:51,927 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:17:53,823 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:17:56,283 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:17:56,283 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:17:57,485 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:18:02,486 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:18:02,798 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:18:02,798 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:18:02,799 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:18:02,799 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:18:02,825 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:18:03,825 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:18:07,800 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:18:11,283 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:18:11,283 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:18:13,437 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:18:14,686 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:18:14,686 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:18:14,687 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:18:14,687 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:18:14,828 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:18:15,828 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:18:18,687 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:18:19,724 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:18:23,725 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:18:26,283 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:18:26,283 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:18:26,546 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:18:26,546 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:18:26,547 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:18:26,547 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:18:26,830 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:18:27,831 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:18:29,547 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:18:34,548 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:18:38,350 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:18:38,351 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:18:38,351 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:18:38,352 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:18:38,834 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:18:39,834 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:18:40,352 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:18:41,283 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:18:41,283 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:18:45,488 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:18:49,725 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:18:50,238 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:18:50,238 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:18:50,239 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:18:50,239 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:18:50,837 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:18:51,239 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:18:51,837 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:18:56,240 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:18:56,283 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:18:56,283 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:19:01,504 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:19:02,126 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:19:02,126 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:19:02,127 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:19:02,127 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:19:02,840 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:19:03,841 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:19:07,128 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:19:11,283 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:19:11,284 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:19:12,452 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:19:13,982 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:19:13,982 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:19:13,983 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:19:13,984 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:19:14,843 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:19:15,844 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:19:17,984 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:19:19,725 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:19:23,726 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:19:25,815 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:19:25,815 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:19:25,815 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:19:25,816 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:19:25,846 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:19:26,283 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:19:26,284 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:19:27,847 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:19:29,442 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:19:34,442 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:19:37,762 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:19:37,762 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:19:37,763 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:19:37,763 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:19:37,849 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:19:39,763 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:19:39,850 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:19:41,291 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:19:41,291 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:19:45,510 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:19:49,574 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:19:49,574 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:19:49,575 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:19:49,575 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:19:49,726 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:19:49,852 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:19:50,726 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:19:51,853 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:19:55,727 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:19:56,291 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:19:56,292 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:20:01,436 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:20:01,478 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:20:01,478 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:20:01,479 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:20:01,479 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:20:01,856 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:20:03,857 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:20:06,480 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:20:11,291 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:20:11,292 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:20:12,459 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:20:13,330 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:20:13,331 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:20:13,331 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:20:13,331 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:20:13,859 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:20:15,860 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:20:18,332 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:20:19,726 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:20:23,727 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:20:25,126 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:20:25,126 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:20:25,127 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:20:25,127 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:20:25,863 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:20:26,291 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:20:26,292 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:20:27,863 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:20:29,518 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:20:34,519 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:20:36,985 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:20:36,986 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:20:36,986 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:20:36,986 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:20:37,866 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:20:39,867 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:20:39,987 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:20:41,292 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:20:41,292 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:20:45,441 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:20:48,866 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:20:48,867 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:20:48,867 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:20:48,867 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:20:48,869 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:20:49,727 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:20:49,869 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:20:50,727 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:20:55,728 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:20:56,292 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:20:56,292 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:21:00,683 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:21:00,684 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:21:00,684 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:21:00,684 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:21:00,872 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:21:01,684 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:21:01,872 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:21:06,685 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:21:11,292 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:21:11,293 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:21:12,500 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:21:12,582 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:21:12,582 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:21:12,583 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:21:12,583 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:21:12,875 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:21:13,876 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:21:17,584 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:21:19,727 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:21:22,728 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:21:24,386 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:21:24,387 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:21:24,387 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:21:24,387 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:21:24,878 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:21:25,879 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:21:26,292 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:21:26,292 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:21:28,461 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:21:33,462 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:21:36,226 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:21:36,231 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:21:36,231 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:21:36,231 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:21:36,882 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:21:37,882 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:21:39,232 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:21:41,292 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:21:41,292 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:21:44,489 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:21:48,090 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:21:48,090 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:21:48,090 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:21:48,091 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:21:48,885 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:21:49,728 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:21:49,728 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:21:49,885 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:21:54,729 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:21:56,292 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:21:56,292 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:21:59,950 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:21:59,950 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:21:59,951 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:21:59,951 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:21:59,951 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:22:00,888 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:22:01,888 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:22:04,952 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:22:09,953 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:22:11,292 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:22:11,293 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:22:11,811 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:22:11,811 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:22:11,812 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:22:11,812 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:22:11,891 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:22:13,892 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:22:15,812 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:22:19,728 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:22:21,729 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:22:23,642 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:22:23,643 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:22:23,643 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:22:23,643 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:22:23,894 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:22:25,895 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:22:26,292 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:22:26,293 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:22:27,477 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:22:32,478 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:22:35,519 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:22:35,520 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:22:35,520 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:22:35,520 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:22:35,897 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:22:37,521 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:22:37,898 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:22:41,292 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:22:41,293 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:22:43,458 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:22:47,442 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:22:47,443 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:22:47,443 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:22:47,443 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:22:47,901 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:22:49,443 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:22:49,729 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:22:49,901 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:22:54,730 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:22:56,293 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:22:56,293 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:22:59,256 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:22:59,257 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:22:59,257 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:22:59,257 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:22:59,904 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:23:00,258 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:23:01,905 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:23:05,258 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:23:10,259 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:23:11,097 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:23:11,098 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:23:11,098 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:23:11,098 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:23:11,293 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:23:11,293 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:23:11,907 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:23:11,908 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:23:15,510 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:23:19,729 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:23:20,730 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:23:22,976 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:23:22,977 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:23:22,977 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:23:22,977 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:23:23,910 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:23:23,911 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:23:25,978 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:23:26,293 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:23:26,294 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:23:31,524 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:23:36,524 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:23:39,915 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:23:41,293 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:23:41,294 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:23:42,439 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:23:47,440 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:23:49,730 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:23:50,086 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:23:50,087 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:23:50,087 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:23:50,226 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:23:50,917 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:23:51,917 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:23:53,227 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:23:56,293 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:23:56,294 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:23:58,439 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:24:01,874 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:24:01,875 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:24:01,875 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:24:01,920 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:24:01,974 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:24:03,921 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:24:03,974 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:24:08,975 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:24:11,293 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:24:11,294 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:24:13,702 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:24:13,702 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:24:13,703 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:24:13,703 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:24:13,923 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:24:14,703 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:24:15,924 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:24:19,704 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:24:19,730 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:24:24,731 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:24:25,500 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:24:25,500 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:24:25,501 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:24:25,501 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:24:25,926 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:24:26,293 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:24:26,294 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:24:27,927 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:24:30,444 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:24:35,445 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:24:37,410 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:24:37,410 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:24:37,411 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:24:37,411 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:24:37,929 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:24:39,930 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:24:41,313 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:24:41,313 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:24:41,514 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:24:46,515 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:24:49,204 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:24:49,205 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:24:49,205 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:24:49,205 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:24:49,731 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:24:49,933 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:24:49,933 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:24:51,731 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:24:56,313 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:24:56,313 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:24:57,482 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:25:01,090 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:25:01,090 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:25:01,091 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:25:01,091 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:25:01,936 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:25:01,936 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:25:03,091 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:25:08,092 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:25:11,313 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:25:11,313 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:25:12,942 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:25:12,942 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:25:12,943 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:25:12,943 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:25:13,939 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:25:13,939 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:25:13,943 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:25:18,944 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:25:19,731 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:25:24,732 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:25:24,757 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:25:24,758 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:25:24,758 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:25:24,758 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:25:24,942 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:25:25,942 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:25:26,313 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:25:26,314 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:25:30,508 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:25:35,509 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:25:36,642 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:25:36,642 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:25:36,643 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:25:36,643 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:25:36,945 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:25:37,945 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:25:40,644 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:25:41,314 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:25:41,314 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:25:46,550 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:25:48,506 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:25:48,506 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:25:48,507 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:25:48,507 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:25:48,948 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:25:49,732 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:25:49,948 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:25:51,733 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:25:56,313 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:25:56,314 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:25:57,480 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:26:00,354 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:26:00,354 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:26:00,355 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:26:00,355 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:26:00,951 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:26:01,951 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:26:03,356 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:26:08,356 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:26:11,313 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:26:11,314 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:26:12,194 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:26:12,194 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:26:12,195 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:26:12,195 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:26:12,954 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:26:13,954 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:26:14,196 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:26:19,196 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:26:19,732 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:26:24,000 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:26:24,006 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:26:24,006 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:26:24,006 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:26:24,957 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:26:25,007 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:26:25,957 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:26:26,313 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:26:26,314 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:26:30,533 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:26:35,534 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:26:35,910 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:26:35,910 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:26:35,911 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:26:35,911 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:26:35,960 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:26:37,960 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:26:40,912 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:26:41,313 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:26:41,314 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:26:46,531 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:26:47,766 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:26:47,767 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:26:47,767 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:26:47,767 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:26:47,963 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:26:49,733 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:26:49,963 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:26:51,734 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:26:56,314 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:26:56,314 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:26:57,529 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:26:59,634 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:26:59,635 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:26:59,635 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:26:59,635 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:26:59,966 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:27:01,966 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:27:02,636 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:27:07,637 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:27:11,314 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:27:11,314 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:27:11,478 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:27:11,539 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:27:11,540 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:27:11,540 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:27:11,969 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:27:13,541 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:27:13,969 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:27:18,541 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:27:19,733 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:27:23,288 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:27:23,289 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:27:23,289 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:27:23,290 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:27:23,972 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:27:23,972 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:27:24,290 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:27:26,314 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:27:26,314 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:27:29,457 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:27:34,458 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:27:35,182 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:27:35,183 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:27:35,183 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:27:35,183 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:27:35,975 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:27:35,975 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:27:40,184 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:27:41,314 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:27:41,315 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:27:45,454 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:27:47,026 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:27:47,026 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:27:47,027 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:27:47,027 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:27:47,978 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:27:47,979 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:27:49,734 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:27:50,734 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:27:55,735 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:27:56,314 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:27:56,315 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:27:58,882 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:27:58,882 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:27:58,883 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:27:58,883 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:27:58,981 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:27:59,982 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:28:00,884 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:28:05,884 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:28:10,692 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:28:10,692 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:28:10,693 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:28:10,693 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:28:10,985 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:28:11,316 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:28:11,316 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:28:11,316 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:28:11,985 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:28:16,509 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:28:19,734 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:28:21,735 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:28:22,570 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:28:22,571 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:28:22,571 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:28:22,571 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:28:22,988 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:28:23,988 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:28:26,315 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:28:26,316 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:28:27,543 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:28:32,544 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:28:34,402 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:28:34,403 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:28:34,403 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:28:34,403 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:28:34,991 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:28:35,991 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:28:38,404 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:28:41,315 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:28:41,316 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:28:43,443 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:28:46,246 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:28:46,247 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:28:46,247 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:28:46,247 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:28:46,994 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:28:47,994 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:28:49,248 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:28:49,735 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:28:54,736 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:28:56,316 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:28:56,316 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:28:58,114 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:28:58,115 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:28:58,115 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:28:58,115 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:28:58,997 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:28:59,998 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:29:00,116 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:29:05,116 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:29:09,941 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:29:09,941 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:29:09,941 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:29:09,942 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:29:10,000 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:29:10,942 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:29:11,316 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:29:11,316 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:29:12,001 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:29:16,487 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:29:19,735 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:29:21,736 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:29:21,854 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:29:21,854 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:29:21,855 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:29:21,855 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:29:22,003 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:29:24,004 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:29:26,316 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:29:26,316 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:29:27,542 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:29:32,542 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:29:33,706 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:29:33,706 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:29:33,707 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:29:33,707 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:29:34,006 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:29:36,007 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:29:37,708 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:29:41,316 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:29:41,316 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:29:43,460 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:29:45,558 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:29:45,558 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:29:45,559 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:29:45,559 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:29:46,010 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:29:46,010 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:29:48,560 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:29:49,736 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:29:53,737 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:29:56,316 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:29:56,316 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:29:57,398 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:29:57,398 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:29:57,399 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:29:57,399 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:29:58,013 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:29:58,013 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:29:59,400 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:30:04,400 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:30:09,187 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:30:09,188 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:30:09,188 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:30:09,189 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:30:10,016 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:30:10,016 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:30:10,189 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:30:11,316 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:30:11,316 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:30:15,447 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:30:19,736 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:30:20,737 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:30:21,066 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:30:21,066 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:30:21,067 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:30:21,067 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:30:22,019 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:30:22,019 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:30:26,068 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:30:26,316 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:30:26,317 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:30:31,504 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:30:32,930 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:30:32,930 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:30:32,931 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:30:32,931 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:30:33,022 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:30:34,022 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:30:36,932 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:30:41,316 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:30:41,317 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:30:42,461 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:30:44,786 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:30:44,786 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:30:44,787 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:30:44,787 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:30:45,025 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:30:46,025 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:30:47,788 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:30:49,737 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:30:53,738 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:30:56,316 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:30:56,317 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:30:56,686 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:30:56,687 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:30:56,687 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:30:56,687 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:30:57,028 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:30:58,028 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:30:59,688 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:31:04,688 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:31:08,488 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:31:08,489 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:31:08,489 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:31:08,489 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:31:09,031 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:31:10,031 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:31:10,490 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:31:11,317 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:31:11,317 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:31:15,507 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:31:19,737 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:31:20,390 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:31:20,391 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:31:20,391 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:31:20,391 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:31:21,034 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:31:21,391 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:31:22,034 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:31:26,317 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:31:26,317 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:31:26,489 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:31:31,490 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:31:32,238 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:31:32,239 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:31:32,239 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:31:32,239 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:31:33,037 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:31:34,037 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:31:37,240 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:31:41,317 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:31:41,317 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:31:42,532 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:31:44,106 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:31:44,107 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:31:44,107 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:31:44,107 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:31:45,039 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:31:46,040 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:31:48,108 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:31:49,738 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:31:53,739 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:31:55,918 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:31:55,918 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:31:55,918 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:31:55,919 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:31:56,042 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:31:56,317 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:31:56,317 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:31:58,043 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:31:59,487 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:32:04,488 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:32:07,814 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:32:07,815 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:32:07,815 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:32:07,815 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:32:08,045 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:32:09,816 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:32:10,045 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:32:11,317 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:32:11,318 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:32:15,537 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:32:19,670 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:32:19,671 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:32:19,671 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:32:19,671 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:32:19,738 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:32:20,048 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:32:20,048 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:32:20,739 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:32:25,740 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:32:26,317 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:32:26,318 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:32:31,498 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:32:31,538 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:32:31,538 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:32:31,539 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:32:31,539 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:32:32,051 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:32:32,051 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:32:36,540 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:32:41,317 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:32:41,318 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:32:42,439 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:32:43,390 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:32:43,391 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:32:43,391 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:32:43,391 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:32:44,054 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:32:44,054 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:32:48,392 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:32:49,739 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:32:53,740 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:32:55,202 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:32:55,202 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:32:55,203 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:32:55,203 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:32:56,057 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:32:56,057 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:32:56,317 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:32:56,318 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:32:59,547 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:33:04,548 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:33:07,094 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:33:07,094 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:33:07,095 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:33:07,095 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:33:08,060 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:33:08,060 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:33:10,096 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:33:11,318 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:33:11,318 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:33:15,538 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:33:18,938 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:33:18,939 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:33:18,939 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:33:18,939 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:33:19,062 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:33:19,739 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:33:20,062 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:33:20,740 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:33:25,741 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:33:26,318 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:33:26,318 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:33:30,748 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:33:30,790 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:33:30,790 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:33:30,791 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:33:30,791 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:33:31,065 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:33:32,065 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:33:35,792 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:33:40,792 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:33:41,318 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:33:41,318 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:33:42,650 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:33:42,650 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:33:42,651 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:33:42,651 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:33:43,067 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:33:44,068 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:33:46,652 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:33:49,740 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:33:51,741 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:33:54,459 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:33:54,460 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:33:54,460 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:33:54,461 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:33:55,070 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:33:56,318 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:33:56,318 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:33:57,071 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:33:57,543 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:34:02,543 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:34:06,410 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:34:06,411 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:34:06,411 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:34:06,411 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:34:07,073 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:34:08,412 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:34:09,074 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:34:11,318 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:34:11,319 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:34:13,487 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:34:18,278 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:34:18,278 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:34:18,279 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:34:18,279 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:34:19,077 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:34:19,279 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:34:19,740 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:34:21,077 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:34:24,741 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:34:26,318 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:34:26,319 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:34:30,100 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:34:30,142 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:34:30,142 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:34:30,143 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:34:30,143 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:34:31,080 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:34:33,080 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:34:35,144 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:34:40,145 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:34:41,318 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:34:41,319 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:34:41,966 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:34:41,967 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:34:41,967 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:34:41,967 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:34:42,082 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:34:45,083 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:34:45,968 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:34:49,741 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:34:51,742 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:34:53,793 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:34:53,794 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:34:53,794 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:34:53,794 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:34:54,085 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:34:55,086 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:34:56,319 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:34:56,319 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:34:57,531 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:35:02,532 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:35:05,690 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:35:05,690 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:35:05,691 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:35:05,691 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:35:06,088 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:35:07,088 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:35:07,692 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:35:11,319 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:35:11,319 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:35:13,536 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:35:17,550 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:35:17,550 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:35:17,551 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:35:17,551 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:35:18,091 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:35:18,551 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:35:19,092 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:35:19,741 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:35:23,742 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:35:26,319 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:35:26,319 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:35:29,358 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:35:29,398 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:35:29,398 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:35:29,399 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:35:29,399 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:35:30,094 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:35:31,094 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:35:34,400 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:35:39,401 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:35:41,203 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:35:41,204 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:35:41,204 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:35:41,205 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:35:41,319 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:35:41,319 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:35:42,097 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:35:43,097 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:35:44,501 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:35:49,502 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:35:49,742 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:35:53,090 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:35:53,091 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:35:53,091 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:35:53,091 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:35:53,100 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:35:55,092 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:35:55,100 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:35:56,319 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:35:56,319 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:36:00,516 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:36:04,974 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:36:04,974 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:36:04,975 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:36:04,975 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:36:05,103 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:36:05,975 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:36:07,103 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:36:10,976 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:36:11,319 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:36:11,319 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:36:16,522 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:36:16,834 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:36:16,834 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:36:16,835 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:36:16,835 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:36:17,105 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:36:19,106 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:36:19,746 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:36:21,747 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:36:26,319 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:36:26,320 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:36:27,549 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:36:28,662 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:36:28,662 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:36:28,663 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:36:28,663 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:36:29,108 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:36:31,109 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:36:32,664 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:36:37,665 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:36:40,449 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:36:40,449 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:36:40,449 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:36:40,449 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:36:41,111 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:36:41,320 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:36:41,320 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:36:43,112 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:36:43,479 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:36:48,480 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:36:49,743 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:36:52,342 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:36:52,343 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:36:52,343 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:36:52,344 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:36:53,114 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:36:54,344 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:36:55,115 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:36:56,319 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:36:56,320 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:36:59,476 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:37:04,198 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:37:04,199 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:37:04,199 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:37:04,199 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:37:05,117 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:37:05,199 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:37:07,118 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:37:10,200 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:37:11,320 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:37:11,320 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:37:15,440 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:37:16,042 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:37:16,042 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:37:16,043 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:37:16,043 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:37:16,120 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:37:17,120 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:37:19,743 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:37:20,744 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:37:25,745 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:37:26,320 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:37:26,320 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:37:27,867 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:37:27,868 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:37:27,868 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:37:27,869 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:37:28,123 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:37:29,123 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:37:30,870 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:37:35,870 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:37:40,871 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:37:42,356 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:37:42,357 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:37:46,556 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:37:49,744 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:37:51,248 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:37:51,248 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:37:51,248 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:37:51,249 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:37:52,128 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:37:52,249 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:37:53,129 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:37:57,250 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:37:57,356 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:37:57,356 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:38:02,507 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:38:03,047 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:38:03,048 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:38:03,048 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:38:03,049 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:38:03,131 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:38:05,132 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:38:08,050 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:38:12,356 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:38:12,357 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:38:13,578 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:38:14,867 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:38:14,867 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:38:14,868 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:38:14,868 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:38:15,134 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:38:17,134 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:38:18,869 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:38:19,744 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:38:24,745 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:38:26,680 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:38:26,680 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:38:26,681 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:38:26,681 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:38:27,137 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:38:27,356 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:38:27,357 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:38:29,137 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:38:30,528 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:38:35,529 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:38:38,525 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:38:38,526 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:38:38,526 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:38:38,527 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:38:39,140 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:38:41,141 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:38:41,528 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:38:42,356 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:38:42,357 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:38:46,550 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:38:49,745 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:38:50,364 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:38:50,365 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:38:50,365 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:38:50,365 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:38:51,143 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:38:52,366 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:38:53,144 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:38:57,357 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:38:57,357 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:38:57,553 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:39:02,213 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:39:02,214 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:39:02,214 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:39:02,215 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:39:03,146 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:39:03,215 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:39:05,147 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:39:08,216 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:39:12,357 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:39:12,357 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:39:13,539 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:39:14,080 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:39:14,081 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:39:14,081 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:39:14,082 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:39:14,149 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:39:15,149 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:39:19,083 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:39:19,745 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:39:24,746 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:39:25,923 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:39:25,924 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:39:25,924 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:39:25,924 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:39:26,151 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:39:27,152 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:39:27,357 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:39:27,357 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:39:30,571 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:39:35,572 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:39:37,768 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:39:37,769 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:39:37,769 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:39:37,769 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:39:38,154 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:39:39,154 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:39:40,770 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:39:42,357 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:39:42,357 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:39:46,529 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:39:49,601 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:39:49,602 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:39:49,602 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:39:49,603 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:39:49,746 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:39:50,157 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:39:51,157 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:39:51,747 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:39:56,747 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:39:57,357 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:39:57,358 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:40:01,461 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:40:01,461 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:40:01,461 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:40:01,462 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:40:02,160 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:40:02,462 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:40:03,160 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:40:07,463 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:40:12,357 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:40:12,358 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:40:12,547 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:40:13,311 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:40:13,311 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:40:13,312 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:40:13,312 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:40:14,163 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:40:15,163 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:40:18,313 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:40:19,746 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:40:23,748 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:40:25,159 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:40:25,159 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:40:25,160 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:40:25,160 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:40:25,166 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:40:27,166 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:40:27,357 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:40:27,358 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:40:29,529 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:40:34,530 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:40:37,028 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:40:37,029 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:40:37,029 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:40:37,029 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:40:37,169 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:40:39,169 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:40:40,030 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:40:42,357 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:40:42,358 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:40:45,503 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:40:48,870 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:40:48,871 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:40:48,871 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:40:48,871 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:40:49,172 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:40:49,747 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:40:50,748 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:40:51,173 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:40:55,748 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:40:57,358 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:40:57,358 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:41:00,705 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:41:00,706 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:41:00,706 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:41:00,706 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:41:01,176 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:41:01,707 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:41:03,176 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:41:06,708 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:41:11,708 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:41:12,358 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:41:12,358 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:41:12,550 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:41:12,550 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:41:12,551 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:41:12,551 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:41:13,179 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:41:15,179 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:41:17,552 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:41:19,751 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:41:22,752 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:41:24,408 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:41:24,408 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:41:24,408 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:41:24,409 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:41:25,182 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:41:27,183 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:41:27,358 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:41:27,358 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:41:28,493 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:41:33,494 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:41:36,259 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:41:36,260 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:41:36,260 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:41:36,260 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:41:37,186 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:41:37,186 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:41:39,261 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:41:42,358 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:41:42,358 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:41:44,575 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:41:48,096 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:41:48,096 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:41:48,097 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:41:48,097 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:41:48,188 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:41:49,189 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:41:49,748 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:41:49,748 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:41:54,749 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:41:57,358 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:41:57,359 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:41:59,950 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:41:59,950 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:41:59,951 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:41:59,951 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:41:59,952 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:42:00,191 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:42:01,192 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:42:04,953 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:42:09,953 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:42:11,806 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:42:11,806 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:42:11,807 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:42:11,807 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:42:12,195 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:42:12,358 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:42:12,359 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:42:13,195 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:42:15,549 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:42:19,748 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:42:20,749 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:42:23,649 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:42:23,649 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:42:23,650 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:42:23,650 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:42:24,198 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:42:25,198 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:42:26,651 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:42:27,358 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:42:27,359 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:42:32,543 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:42:35,474 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:42:35,475 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:42:35,475 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:42:35,476 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:42:36,201 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:42:37,201 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:42:38,477 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:42:42,358 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:42:42,359 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:42:43,478 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:42:47,317 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:42:47,318 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:42:47,318 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:42:47,319 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:42:48,204 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:42:49,204 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:42:49,319 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:42:49,749 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:42:54,750 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:42:57,358 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:42:57,359 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:42:59,167 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:42:59,167 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:42:59,167 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:42:59,168 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:42:59,207 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:43:00,168 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:43:01,208 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:43:05,169 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:43:10,169 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:43:11,002 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:43:11,003 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:43:11,003 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:43:11,004 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:43:11,210 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:43:12,358 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:43:12,359 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:43:13,211 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:43:15,500 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:43:19,749 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:43:20,750 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:43:22,836 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:43:22,836 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:43:22,836 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:43:22,837 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:43:23,213 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:43:25,214 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:43:25,837 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:43:27,359 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:43:27,359 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:43:31,490 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:43:34,709 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: partial_history +2024-05-26 01:43:34,709 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:43:34,710 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:43:34,710 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:43:35,216 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:43:36,710 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:43:37,217 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:43:41,711 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:43:42,359 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:43:42,359 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:43:47,551 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:43:49,750 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:43:50,060 DEBUG SenderThread:53122 [sender.py:send():378] send: telemetry +2024-05-26 01:43:50,061 DEBUG SenderThread:53122 [sender.py:send():378] send: exit +2024-05-26 01:43:50,061 INFO SenderThread:53122 [sender.py:send_exit():585] handling exit code: 0 +2024-05-26 01:43:50,062 INFO SenderThread:53122 [sender.py:send_exit():587] handling runtime: 6780 +2024-05-26 01:43:50,062 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:43:50,062 INFO SenderThread:53122 [sender.py:send_exit():593] send defer +2024-05-26 01:43:50,062 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: defer +2024-05-26 01:43:50,062 INFO HandlerThread:53122 [handler.py:handle_request_defer():184] handle defer: 0 +2024-05-26 01:43:50,062 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: defer +2024-05-26 01:43:50,062 INFO SenderThread:53122 [sender.py:send_request_defer():609] handle sender defer: 0 +2024-05-26 01:43:50,063 INFO SenderThread:53122 [sender.py:transition_state():613] send defer: 1 +2024-05-26 01:43:50,063 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: defer +2024-05-26 01:43:50,063 INFO HandlerThread:53122 [handler.py:handle_request_defer():184] handle defer: 1 +2024-05-26 01:43:50,063 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: defer +2024-05-26 01:43:50,063 INFO SenderThread:53122 [sender.py:send_request_defer():609] handle sender defer: 1 +2024-05-26 01:43:50,063 INFO SenderThread:53122 [sender.py:transition_state():613] send defer: 2 +2024-05-26 01:43:50,063 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: defer +2024-05-26 01:43:50,063 INFO HandlerThread:53122 [handler.py:handle_request_defer():184] handle defer: 2 +2024-05-26 01:43:50,063 INFO HandlerThread:53122 [system_monitor.py:finish():203] Stopping system monitor +2024-05-26 01:43:50,063 DEBUG SystemMonitor:53122 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-05-26 01:43:50,063 INFO HandlerThread:53122 [interfaces.py:finish():200] Joined cpu monitor +2024-05-26 01:43:50,064 DEBUG SystemMonitor:53122 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-05-26 01:43:50,064 INFO HandlerThread:53122 [interfaces.py:finish():200] Joined disk monitor +2024-05-26 01:43:50,087 INFO HandlerThread:53122 [interfaces.py:finish():200] Joined gpu monitor +2024-05-26 01:43:50,087 INFO HandlerThread:53122 [interfaces.py:finish():200] Joined memory monitor +2024-05-26 01:43:50,087 INFO HandlerThread:53122 [interfaces.py:finish():200] Joined network monitor +2024-05-26 01:43:50,087 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: defer +2024-05-26 01:43:50,087 INFO SenderThread:53122 [sender.py:send_request_defer():609] handle sender defer: 2 +2024-05-26 01:43:50,087 INFO SenderThread:53122 [sender.py:transition_state():613] send defer: 3 +2024-05-26 01:43:50,087 DEBUG SenderThread:53122 [sender.py:send():378] send: stats +2024-05-26 01:43:50,088 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: defer +2024-05-26 01:43:50,088 INFO HandlerThread:53122 [handler.py:handle_request_defer():184] handle defer: 3 +2024-05-26 01:43:50,088 DEBUG SenderThread:53122 [sender.py:send():378] send: history +2024-05-26 01:43:50,088 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: summary_record +2024-05-26 01:43:50,088 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:43:50,088 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: defer +2024-05-26 01:43:50,088 INFO SenderThread:53122 [sender.py:send_request_defer():609] handle sender defer: 3 +2024-05-26 01:43:50,088 INFO SenderThread:53122 [sender.py:transition_state():613] send defer: 4 +2024-05-26 01:43:50,089 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: defer +2024-05-26 01:43:50,089 INFO HandlerThread:53122 [handler.py:handle_request_defer():184] handle defer: 4 +2024-05-26 01:43:50,089 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: defer +2024-05-26 01:43:50,089 INFO SenderThread:53122 [sender.py:send_request_defer():609] handle sender defer: 4 +2024-05-26 01:43:50,089 INFO SenderThread:53122 [sender.py:transition_state():613] send defer: 5 +2024-05-26 01:43:50,089 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: defer +2024-05-26 01:43:50,089 INFO HandlerThread:53122 [handler.py:handle_request_defer():184] handle defer: 5 +2024-05-26 01:43:50,089 DEBUG SenderThread:53122 [sender.py:send():378] send: summary +2024-05-26 01:43:50,089 INFO SenderThread:53122 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-26 01:43:50,089 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: defer +2024-05-26 01:43:50,089 INFO SenderThread:53122 [sender.py:send_request_defer():609] handle sender defer: 5 +2024-05-26 01:43:50,089 INFO SenderThread:53122 [sender.py:transition_state():613] send defer: 6 +2024-05-26 01:43:50,089 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: defer +2024-05-26 01:43:50,089 INFO HandlerThread:53122 [handler.py:handle_request_defer():184] handle defer: 6 +2024-05-26 01:43:50,089 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: defer +2024-05-26 01:43:50,090 INFO SenderThread:53122 [sender.py:send_request_defer():609] handle sender defer: 6 +2024-05-26 01:43:50,092 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:43:50,221 INFO SenderThread:53122 [sender.py:transition_state():613] send defer: 7 +2024-05-26 01:43:50,221 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: defer +2024-05-26 01:43:50,221 INFO HandlerThread:53122 [handler.py:handle_request_defer():184] handle defer: 7 +2024-05-26 01:43:50,222 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/config.yaml +2024-05-26 01:43:50,222 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: defer +2024-05-26 01:43:50,222 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:43:50,222 INFO SenderThread:53122 [sender.py:send_request_defer():609] handle sender defer: 7 +2024-05-26 01:43:50,780 INFO SenderThread:53122 [sender.py:transition_state():613] send defer: 8 +2024-05-26 01:43:50,780 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: defer +2024-05-26 01:43:50,780 INFO HandlerThread:53122 [handler.py:handle_request_defer():184] handle defer: 8 +2024-05-26 01:43:50,780 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: defer +2024-05-26 01:43:50,780 INFO SenderThread:53122 [sender.py:send_request_defer():609] handle sender defer: 8 +2024-05-26 01:43:50,780 INFO SenderThread:53122 [job_builder.py:build():432] Attempting to build job artifact +2024-05-26 01:43:50,780 INFO SenderThread:53122 [job_builder.py:_get_source_type():565] is repo sourced job +2024-05-26 01:43:50,781 WARNING SenderThread:53122 [job_builder.py:_log_if_verbose():267] No program path found, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job +2024-05-26 01:43:50,781 INFO SenderThread:53122 [sender.py:transition_state():613] send defer: 9 +2024-05-26 01:43:50,781 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: defer +2024-05-26 01:43:50,781 INFO HandlerThread:53122 [handler.py:handle_request_defer():184] handle defer: 9 +2024-05-26 01:43:50,781 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: defer +2024-05-26 01:43:50,781 INFO SenderThread:53122 [sender.py:send_request_defer():609] handle sender defer: 9 +2024-05-26 01:43:50,781 INFO SenderThread:53122 [dir_watcher.py:finish():358] shutting down directory watcher +2024-05-26 01:43:51,062 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: poll_exit +2024-05-26 01:43:51,222 INFO Thread-12 :53122 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:43:51,222 INFO SenderThread:53122 [dir_watcher.py:finish():388] scan: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files +2024-05-26 01:43:51,222 INFO SenderThread:53122 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/conda-environment.yaml conda-environment.yaml +2024-05-26 01:43:51,222 INFO SenderThread:53122 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log output.log +2024-05-26 01:43:51,223 INFO SenderThread:53122 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-metadata.json wandb-metadata.json +2024-05-26 01:43:51,224 INFO SenderThread:53122 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/config.yaml config.yaml +2024-05-26 01:43:51,226 INFO SenderThread:53122 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/requirements.txt requirements.txt +2024-05-26 01:43:51,226 INFO SenderThread:53122 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json wandb-summary.json +2024-05-26 01:43:51,226 INFO SenderThread:53122 [sender.py:transition_state():613] send defer: 10 +2024-05-26 01:43:51,226 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: poll_exit +2024-05-26 01:43:51,226 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: defer +2024-05-26 01:43:51,228 INFO HandlerThread:53122 [handler.py:handle_request_defer():184] handle defer: 10 +2024-05-26 01:43:51,229 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: defer +2024-05-26 01:43:51,229 INFO SenderThread:53122 [sender.py:send_request_defer():609] handle sender defer: 10 +2024-05-26 01:43:51,229 INFO SenderThread:53122 [file_pusher.py:finish():169] shutting down file pusher +2024-05-26 01:43:51,578 INFO wandb-upload_3:53122 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/requirements.txt +2024-05-26 01:43:51,591 INFO wandb-upload_2:53122 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/config.yaml +2024-05-26 01:43:51,602 INFO wandb-upload_0:53122 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/conda-environment.yaml +2024-05-26 01:43:51,613 INFO wandb-upload_4:53122 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/wandb-summary.json +2024-05-26 01:43:51,833 INFO wandb-upload_1:53122 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/files/output.log +2024-05-26 01:43:52,033 INFO Thread-11 (_thread_body):53122 [sender.py:transition_state():613] send defer: 11 +2024-05-26 01:43:52,034 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: defer +2024-05-26 01:43:52,034 INFO HandlerThread:53122 [handler.py:handle_request_defer():184] handle defer: 11 +2024-05-26 01:43:52,034 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: defer +2024-05-26 01:43:52,034 INFO SenderThread:53122 [sender.py:send_request_defer():609] handle sender defer: 11 +2024-05-26 01:43:52,034 INFO SenderThread:53122 [file_pusher.py:join():175] waiting for file pusher +2024-05-26 01:43:52,035 INFO SenderThread:53122 [sender.py:transition_state():613] send defer: 12 +2024-05-26 01:43:52,035 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: defer +2024-05-26 01:43:52,035 INFO HandlerThread:53122 [handler.py:handle_request_defer():184] handle defer: 12 +2024-05-26 01:43:52,035 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: defer +2024-05-26 01:43:52,035 INFO SenderThread:53122 [sender.py:send_request_defer():609] handle sender defer: 12 +2024-05-26 01:43:52,035 INFO SenderThread:53122 [file_stream.py:finish():601] file stream finish called +2024-05-26 01:43:52,062 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: poll_exit +2024-05-26 01:43:52,454 INFO SenderThread:53122 [file_stream.py:finish():605] file stream finish is done +2024-05-26 01:43:52,454 INFO SenderThread:53122 [sender.py:transition_state():613] send defer: 13 +2024-05-26 01:43:52,454 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: poll_exit +2024-05-26 01:43:52,454 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: defer +2024-05-26 01:43:52,454 INFO HandlerThread:53122 [handler.py:handle_request_defer():184] handle defer: 13 +2024-05-26 01:43:52,455 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: defer +2024-05-26 01:43:52,455 INFO SenderThread:53122 [sender.py:send_request_defer():609] handle sender defer: 13 +2024-05-26 01:43:52,455 INFO SenderThread:53122 [sender.py:transition_state():613] send defer: 14 +2024-05-26 01:43:52,455 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: defer +2024-05-26 01:43:52,455 INFO HandlerThread:53122 [handler.py:handle_request_defer():184] handle defer: 14 +2024-05-26 01:43:52,455 DEBUG SenderThread:53122 [sender.py:send():378] send: final +2024-05-26 01:43:52,455 DEBUG SenderThread:53122 [sender.py:send():378] send: footer +2024-05-26 01:43:52,455 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: defer +2024-05-26 01:43:52,455 INFO SenderThread:53122 [sender.py:send_request_defer():609] handle sender defer: 14 +2024-05-26 01:43:52,456 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: poll_exit +2024-05-26 01:43:52,456 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: poll_exit +2024-05-26 01:43:52,456 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: internal_messages +2024-05-26 01:43:52,456 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: server_info +2024-05-26 01:43:52,456 DEBUG SenderThread:53122 [sender.py:send_request():405] send_request: server_info +2024-05-26 01:43:52,498 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: get_summary +2024-05-26 01:43:52,498 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: sampled_history +2024-05-26 01:43:52,573 DEBUG HandlerThread:53122 [handler.py:handle_request():158] handle_request: shutdown +2024-05-26 01:43:52,573 INFO HandlerThread:53122 [handler.py:finish():882] shutting down handler +2024-05-26 01:43:53,457 INFO WriterThread:53122 [datastore.py:close():296] close: /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/run-kk8bhidf.wandb +2024-05-26 01:43:53,573 INFO SenderThread:53122 [sender.py:finish():1545] shutting down sender +2024-05-26 01:43:53,573 INFO SenderThread:53122 [file_pusher.py:finish():169] shutting down file pusher +2024-05-26 01:43:53,573 INFO SenderThread:53122 [file_pusher.py:join():175] waiting for file pusher diff --git a/runseed42/wandb/run-20240525_235049-kk8bhidf/logs/debug.log b/runseed42/wandb/run-20240525_235049-kk8bhidf/logs/debug.log new file mode 100644 index 0000000000000000000000000000000000000000..af3be01731511e4c1d0792a5f651a06ccbe001bd --- /dev/null +++ b/runseed42/wandb/run-20240525_235049-kk8bhidf/logs/debug.log @@ -0,0 +1,36 @@ +2024-05-25 23:50:49,203 INFO MainThread:53068 [wandb_setup.py:_flush():76] Current SDK version is 0.17.0 +2024-05-25 23:50:49,203 INFO MainThread:53068 [wandb_setup.py:_flush():76] Configure stats pid to 53068 +2024-05-25 23:50:49,203 INFO MainThread:53068 [wandb_setup.py:_flush():76] Loading settings from /root/.config/wandb/settings +2024-05-25 23:50:49,203 INFO MainThread:53068 [wandb_setup.py:_flush():76] Loading settings from /root/mistral-finetune/wandb/settings +2024-05-25 23:50:49,203 INFO MainThread:53068 [wandb_setup.py:_flush():76] Loading settings from environment variables: {} +2024-05-25 23:50:49,203 WARNING MainThread:53068 [wandb_setup.py:_flush():76] Could not find program at -m train +2024-05-25 23:50:49,203 INFO MainThread:53068 [wandb_setup.py:_flush():76] Inferring run settings from compute environment: {'program_relpath': None, 'program': '-m train'} +2024-05-25 23:50:49,203 INFO MainThread:53068 [wandb_setup.py:_flush():76] Applying login settings: {'api_key': '***REDACTED***'} +2024-05-25 23:50:49,203 INFO MainThread:53068 [wandb_setup.py:_flush():76] Applying login settings: {'api_key': '***REDACTED***'} +2024-05-25 23:50:49,203 INFO MainThread:53068 [wandb_setup.py:_flush():76] Applying login settings: {} +2024-05-25 23:50:49,203 INFO MainThread:53068 [wandb_init.py:_log_setup():520] Logging user logs to /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/logs/debug.log +2024-05-25 23:50:49,203 INFO MainThread:53068 [wandb_init.py:_log_setup():521] Logging internal logs to /root/mistral-finetune/runseed42/wandb/run-20240525_235049-kk8bhidf/logs/debug-internal.log +2024-05-25 23:50:49,203 INFO MainThread:53068 [wandb_init.py:init():560] calling init triggers +2024-05-25 23:50:49,203 INFO MainThread:53068 [wandb_init.py:init():567] wandb.init called with sweep_config: {} +config: {'data': {'data': '', 'shuffle': False, 'instruct_data': '/root/data/mol_instructions_train.jsonl', 'eval_instruct_data': '', 'instruct': {'shuffle': True, 'dynamic_chunk_fn_call': True}}, 'model_id_or_path': '/root/mistral_models/7B-v0.3', 'run_dir': '/root/mistral-finetune/runseed42', 'optim': {'lr': 6e-05, 'weight_decay': 0.1, 'pct_start': 0.05}, 'seed': 42, 'num_microbatches': 1, 'seq_len': 32768, 'batch_size': 2, 'max_norm': 1.0, 'max_steps': 500, 'log_freq': 1, 'ckpt_freq': 100, 'ckpt_only_lora': False, 'no_ckpt': False, 'num_ckpt_keep': 3, 'eval_freq': 100, 'no_eval': True, 'checkpoint': True, 'world_size': 1, 'wandb': {'project': 'CHEMISTral7b-ft', 'offline': False, 'key': 'aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df', 'run_name': 'runseed42'}, 'mlflow': {'tracking_uri': None, 'experiment_name': None}, 'lora': {'enable': True, 'rank': 64, 'dropout': 0.0, 'scaling': 2.0}} +2024-05-25 23:50:49,203 INFO MainThread:53068 [wandb_init.py:init():610] starting backend +2024-05-25 23:50:49,203 INFO MainThread:53068 [wandb_init.py:init():614] setting up manager +2024-05-25 23:50:49,204 INFO MainThread:53068 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn +2024-05-25 23:50:49,204 INFO MainThread:53068 [wandb_init.py:init():622] backend started and connected +2024-05-25 23:50:49,205 INFO MainThread:53068 [wandb_init.py:init():711] updated telemetry +2024-05-25 23:50:49,208 INFO MainThread:53068 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout +2024-05-25 23:50:49,551 INFO MainThread:53068 [wandb_run.py:_on_init():2396] communicating current version +2024-05-25 23:50:49,581 INFO MainThread:53068 [wandb_run.py:_on_init():2405] got version response +2024-05-25 23:50:49,582 INFO MainThread:53068 [wandb_init.py:init():795] starting run threads in backend +2024-05-25 23:50:50,644 INFO MainThread:53068 [wandb_run.py:_console_start():2374] atexit reg +2024-05-25 23:50:50,644 INFO MainThread:53068 [wandb_run.py:_redirect():2229] redirect: wrap_raw +2024-05-25 23:50:50,644 INFO MainThread:53068 [wandb_run.py:_redirect():2294] Wrapping output streams. +2024-05-25 23:50:50,644 INFO MainThread:53068 [wandb_run.py:_redirect():2319] Redirects installed. +2024-05-25 23:50:50,645 INFO MainThread:53068 [wandb_init.py:init():838] run started, returning control to user process +2024-05-26 01:43:50,060 INFO MainThread:53068 [wandb_run.py:_finish():2103] finishing run artsy/CHEMISTral7b-ft/kk8bhidf +2024-05-26 01:43:50,061 INFO MainThread:53068 [wandb_run.py:_atexit_cleanup():2343] got exitcode: 0 +2024-05-26 01:43:50,061 INFO MainThread:53068 [wandb_run.py:_restore():2326] restore +2024-05-26 01:43:50,061 INFO MainThread:53068 [wandb_run.py:_restore():2332] restore done +2024-05-26 01:43:53,575 INFO MainThread:53068 [wandb_run.py:_footer_history_summary_info():3994] rendering history +2024-05-26 01:43:53,575 INFO MainThread:53068 [wandb_run.py:_footer_history_summary_info():4026] rendering summary +2024-05-26 01:43:53,578 INFO MainThread:53068 [wandb_run.py:_footer_sync_info():3953] logging synced files diff --git a/runseed42/wandb/run-20240525_235049-kk8bhidf/run-kk8bhidf.wandb b/runseed42/wandb/run-20240525_235049-kk8bhidf/run-kk8bhidf.wandb new file mode 100644 index 0000000000000000000000000000000000000000..f46d79209ad1ea933bbfced4395887e4f76b3129 Binary files /dev/null and b/runseed42/wandb/run-20240525_235049-kk8bhidf/run-kk8bhidf.wandb differ diff --git a/runseed5/args.yaml b/runseed5/args.yaml new file mode 100644 index 0000000000000000000000000000000000000000..761bde72024fdbc126981d3ba7497994dcd5f828 --- /dev/null +++ b/runseed5/args.yaml @@ -0,0 +1,42 @@ +batch_size: 2 +checkpoint: true +ckpt_freq: 100 +ckpt_only_lora: false +data: + data: '' + eval_instruct_data: '' + instruct: + dynamic_chunk_fn_call: true + shuffle: true + instruct_data: /root/data/mol_instructions_train.jsonl + shuffle: false +eval_freq: 100 +log_freq: 1 +lora: + dropout: 0.0 + enable: true + rank: 64 + scaling: 2.0 +max_norm: 1.0 +max_steps: 500 +mlflow: + experiment_name: null + tracking_uri: null +model_id_or_path: /root/mistral_models/7B-v0.3 +no_ckpt: false +no_eval: true +num_ckpt_keep: 3 +num_microbatches: 1 +optim: + lr: 6.0e-05 + pct_start: 0.05 + weight_decay: 0.1 +run_dir: /root/mistral-finetune/runseed5 +seed: 5 +seq_len: 32768 +wandb: + key: aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df + offline: false + project: CHEMISTral7b-ft + run_name: run1 +world_size: 1 diff --git a/runseed5/checkpoints/checkpoint_000300/consolidated/consolidated.safetensors b/runseed5/checkpoints/checkpoint_000300/consolidated/consolidated.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..22ae8a199f52c68a86317981ae6a1b751a743aca --- /dev/null +++ b/runseed5/checkpoints/checkpoint_000300/consolidated/consolidated.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:b1eca05a5dfb9293c8f8dfce2f6f44a31239e10251d3bc2e11c6ec9a9aa800ed +size 14496078512 diff --git a/runseed5/checkpoints/checkpoint_000300/consolidated/params.json b/runseed5/checkpoints/checkpoint_000300/consolidated/params.json new file mode 100644 index 0000000000000000000000000000000000000000..f6f914db94794fe23c78add929abbca1c57efa3c --- /dev/null +++ b/runseed5/checkpoints/checkpoint_000300/consolidated/params.json @@ -0,0 +1,18 @@ +{ + "dim": 4096, + "n_layers": 32, + "head_dim": 128, + "hidden_dim": 14336, + "n_heads": 32, + "n_kv_heads": 8, + "norm_eps": 1e-05, + "vocab_size": 32768, + "rope_theta": 1000000.0, + "lora": { + "enable": true, + "rank": 64, + "dropout": 0.0, + "scaling": 2.0 + }, + "moe": null +} \ No newline at end of file diff --git a/runseed5/checkpoints/checkpoint_000300/consolidated/tokenizer.model.v3 b/runseed5/checkpoints/checkpoint_000300/consolidated/tokenizer.model.v3 new file mode 100644 index 0000000000000000000000000000000000000000..d8233e5b061987d32b63dbfb38fe86d7d4fc8a18 Binary files /dev/null and b/runseed5/checkpoints/checkpoint_000300/consolidated/tokenizer.model.v3 differ diff --git a/runseed5/checkpoints/checkpoint_000400/consolidated/consolidated.safetensors b/runseed5/checkpoints/checkpoint_000400/consolidated/consolidated.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..da2cfd6d12a4ddcc35c4cf06db1800f911beaf95 --- /dev/null +++ b/runseed5/checkpoints/checkpoint_000400/consolidated/consolidated.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:fcb154db0e26f7f96bae9e2f170e121c096f00f468871648a56224e9b84f6c8c +size 14496078512 diff --git a/runseed5/checkpoints/checkpoint_000400/consolidated/params.json b/runseed5/checkpoints/checkpoint_000400/consolidated/params.json new file mode 100644 index 0000000000000000000000000000000000000000..f6f914db94794fe23c78add929abbca1c57efa3c --- /dev/null +++ b/runseed5/checkpoints/checkpoint_000400/consolidated/params.json @@ -0,0 +1,18 @@ +{ + "dim": 4096, + "n_layers": 32, + "head_dim": 128, + "hidden_dim": 14336, + "n_heads": 32, + "n_kv_heads": 8, + "norm_eps": 1e-05, + "vocab_size": 32768, + "rope_theta": 1000000.0, + "lora": { + "enable": true, + "rank": 64, + "dropout": 0.0, + "scaling": 2.0 + }, + "moe": null +} \ No newline at end of file diff --git a/runseed5/checkpoints/checkpoint_000400/consolidated/tokenizer.model.v3 b/runseed5/checkpoints/checkpoint_000400/consolidated/tokenizer.model.v3 new file mode 100644 index 0000000000000000000000000000000000000000..d8233e5b061987d32b63dbfb38fe86d7d4fc8a18 Binary files /dev/null and b/runseed5/checkpoints/checkpoint_000400/consolidated/tokenizer.model.v3 differ diff --git a/runseed5/checkpoints/checkpoint_000500/consolidated/consolidated.safetensors b/runseed5/checkpoints/checkpoint_000500/consolidated/consolidated.safetensors new file mode 100644 index 0000000000000000000000000000000000000000..299b41930b1870130c21df96b72405d3ce1fbf3b --- /dev/null +++ b/runseed5/checkpoints/checkpoint_000500/consolidated/consolidated.safetensors @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:163c214630accaa54ba53c2631a01bd9e5c2461ff3451bc06882d6aac0199470 +size 14496078512 diff --git a/runseed5/checkpoints/checkpoint_000500/consolidated/params.json b/runseed5/checkpoints/checkpoint_000500/consolidated/params.json new file mode 100644 index 0000000000000000000000000000000000000000..f6f914db94794fe23c78add929abbca1c57efa3c --- /dev/null +++ b/runseed5/checkpoints/checkpoint_000500/consolidated/params.json @@ -0,0 +1,18 @@ +{ + "dim": 4096, + "n_layers": 32, + "head_dim": 128, + "hidden_dim": 14336, + "n_heads": 32, + "n_kv_heads": 8, + "norm_eps": 1e-05, + "vocab_size": 32768, + "rope_theta": 1000000.0, + "lora": { + "enable": true, + "rank": 64, + "dropout": 0.0, + "scaling": 2.0 + }, + "moe": null +} \ No newline at end of file diff --git a/runseed5/checkpoints/checkpoint_000500/consolidated/tokenizer.model.v3 b/runseed5/checkpoints/checkpoint_000500/consolidated/tokenizer.model.v3 new file mode 100644 index 0000000000000000000000000000000000000000..d8233e5b061987d32b63dbfb38fe86d7d4fc8a18 Binary files /dev/null and b/runseed5/checkpoints/checkpoint_000500/consolidated/tokenizer.model.v3 differ diff --git a/runseed5/metrics.train.jsonl b/runseed5/metrics.train.jsonl new file mode 100644 index 0000000000000000000000000000000000000000..24a6a02f708f73a870156fe1d47832ea83e2bdae --- /dev/null +++ b/runseed5/metrics.train.jsonl @@ -0,0 +1,500 @@ +{"lr": 2.3999999999999974e-06, "step": 1, "loss": 2.262953042984009, "percent_done": 0.2, "peak_allocated_mem": 63.57235288619995, "allocated_mem": 24.13692855834961, "wps": 88.16643749820423, "avg_wps": 88.16643749820423, "eta_in_seconds": 370917.37999129295, "at": "2024-05-25T21:59:10.332723"} +{"lr": 2.646387992434257e-06, "step": 2, "loss": 2.1094534397125244, "percent_done": 0.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13880491256714, "wps": 5641.716752178008, "avg_wps": 173.61961874185505, "eta_in_seconds": 187979.49354171753, "at": "2024-05-25T21:59:21.950364"} +{"lr": 3.3813362028748325e-06, "step": 3, "loss": 1.950036644935608, "percent_done": 0.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1414213180542, "wps": 5581.752965709586, "avg_wps": 256.44114573749755, "eta_in_seconds": 127013.12773474057, "at": "2024-05-25T21:59:33.692711"} +{"lr": 4.592269463674938e-06, "step": 4, "loss": 2.1372272968292236, "percent_done": 0.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5568.708412525151, "avg_wps": 336.7523364839041, "eta_in_seconds": 96527.48467731476, "at": "2024-05-25T21:59:45.462542"} +{"lr": 6.258468371008163e-06, "step": 5, "loss": 2.4573512077331543, "percent_done": 1.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5556.700210769298, "avg_wps": 414.65804703405377, "eta_in_seconds": 78233.90919828415, "at": "2024-05-25T21:59:57.257808"} +{"lr": 8.351423799612423e-06, "step": 6, "loss": 2.1645777225494385, "percent_done": 1.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139694690704346, "wps": 5539.8033496717935, "avg_wps": 490.25053920820994, "eta_in_seconds": 66037.22262557347, "at": "2024-05-25T22:00:09.089028"} +{"lr": 1.0835324701827431e-05, "step": 7, "loss": 1.8717948198318481, "percent_done": 1.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.138723373413086, "wps": 5544.172879147123, "avg_wps": 563.6520212491118, "eta_in_seconds": 57321.2669909341, "at": "2024-05-25T22:00:20.910955"} +{"lr": 1.3667670844548846e-05, "step": 8, "loss": 2.1801249980926514, "percent_done": 1.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5528.093002828564, "avg_wps": 634.9254699210051, "eta_in_seconds": 50783.45967757702, "at": "2024-05-25T22:00:32.767220"} +{"lr": 1.6799999999999995e-05, "step": 9, "loss": 2.0575146675109863, "percent_done": 1.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5534.476640134749, "avg_wps": 704.1928640175574, "eta_in_seconds": 45695.11797722181, "at": "2024-05-25T22:00:44.609869"} +{"lr": 2.017871714788541e-05, "step": 10, "loss": 1.8830426931381226, "percent_done": 2.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139169692993164, "wps": 5542.375561228271, "avg_wps": 771.5443544496028, "eta_in_seconds": 41621.24940037727, "at": "2024-05-25T22:00:56.435655"} +{"lr": 2.37460115010474e-05, "step": 11, "loss": 2.232516288757324, "percent_done": 2.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5536.732403121099, "avg_wps": 837.0347008453684, "eta_in_seconds": 38286.47004435279, "at": "2024-05-25T22:01:08.273425"} +{"lr": 2.7440845664062507e-05, "step": 12, "loss": 1.8419462442398071, "percent_done": 2.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5539.74138602249, "avg_wps": 900.7559521764189, "eta_in_seconds": 35505.25302966436, "at": "2024-05-25T22:01:20.104820"} +{"lr": 3.12e-05, "step": 13, "loss": 1.7451030015945435, "percent_done": 2.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1411771774292, "wps": 5539.755341678419, "avg_wps": 962.7734871603661, "eta_in_seconds": 33150.09441538957, "at": "2024-05-25T22:01:31.936253"} +{"lr": 3.495915433593748e-05, "step": 14, "loss": 1.5826107263565063, "percent_done": 2.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5539.311251368314, "avg_wps": 1023.153623997986, "eta_in_seconds": 31129.729937859942, "at": "2024-05-25T22:01:43.768550"} +{"lr": 3.86539884989526e-05, "step": 15, "loss": 1.8554575443267822, "percent_done": 3.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.140127182006836, "wps": 5528.257214583447, "avg_wps": 1081.933096932108, "eta_in_seconds": 29377.93481882413, "at": "2024-05-25T22:01:55.624507"} +{"lr": 4.222128285211459e-05, "step": 16, "loss": 1.8528378009796143, "percent_done": 3.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5531.100390981026, "avg_wps": 1139.2060386867545, "eta_in_seconds": 27843.447912693024, "at": "2024-05-25T22:02:07.474357"} +{"lr": 4.56e-05, "step": 17, "loss": 1.729903221130371, "percent_done": 3.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5536.814820374232, "avg_wps": 1195.0388768566274, "eta_in_seconds": 26487.747480869293, "at": "2024-05-25T22:02:19.312027"} +{"lr": 4.873232915545115e-05, "step": 18, "loss": 2.0164880752563477, "percent_done": 3.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5527.944920430914, "avg_wps": 1249.4466271322206, "eta_in_seconds": 25281.873842424815, "at": "2024-05-25T22:02:31.168654"} +{"lr": 5.156467529817257e-05, "step": 19, "loss": 1.915980339050293, "percent_done": 3.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5518.685654291463, "avg_wps": 1302.4778394687057, "eta_in_seconds": 24202.189891275608, "at": "2024-05-25T22:02:43.045117"} +{"lr": 5.404857620038757e-05, "step": 20, "loss": 1.928839087486267, "percent_done": 4.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14018678665161, "wps": 5525.959470694772, "avg_wps": 1354.2296114341582, "eta_in_seconds": 23228.911651611328, "at": "2024-05-25T22:02:54.905990"} +{"lr": 5.6141531628991836e-05, "step": 21, "loss": 1.9956589937210083, "percent_done": 4.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5530.314412356966, "avg_wps": 1404.741861693786, "eta_in_seconds": 22346.984065918696, "at": "2024-05-25T22:03:06.757515"} +{"lr": 5.780773053632506e-05, "step": 22, "loss": 1.6539652347564697, "percent_done": 4.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5546.238248460089, "avg_wps": 1454.0966576327437, "eta_in_seconds": 21543.415175026115, "at": "2024-05-25T22:03:18.575075"} +{"lr": 5.9018663797125166e-05, "step": 23, "loss": 1.766621470451355, "percent_done": 4.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5537.985655685933, "avg_wps": 1502.262606911442, "eta_in_seconds": 20809.059518741527, "at": "2024-05-25T22:03:30.410244"} +{"lr": 5.975361200756574e-05, "step": 24, "loss": 1.3346548080444336, "percent_done": 4.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5539.707781091524, "avg_wps": 1549.311262478215, "eta_in_seconds": 20134.841045498848, "at": "2024-05-25T22:03:42.241800"} +{"lr": 6e-05, "step": 25, "loss": 1.706301212310791, "percent_done": 5.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14044427871704, "wps": 5545.542833733442, "avg_wps": 1595.2953608999255, "eta_in_seconds": 19513.377123117447, "at": "2024-05-25T22:03:54.060805"} +{"lr": 5.9999343854031334e-05, "step": 26, "loss": 1.46425199508667, "percent_done": 5.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5543.427451060901, "avg_wps": 1640.226112090874, "eta_in_seconds": 18938.89127298502, "at": "2024-05-25T22:04:05.884316"} +{"lr": 5.999737544482728e-05, "step": 27, "loss": 2.186837911605835, "percent_done": 5.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139450550079346, "wps": 5539.600493658582, "avg_wps": 1684.132631983322, "eta_in_seconds": 18406.227283592576, "at": "2024-05-25T22:04:17.715992"} +{"lr": 5.999409485849245e-05, "step": 28, "loss": 1.7592682838439941, "percent_done": 5.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5540.458016107884, "avg_wps": 1727.0643725974264, "eta_in_seconds": 17910.73482309069, "at": "2024-05-25T22:04:29.545819"} +{"lr": 5.9989502238530296e-05, "step": 29, "loss": 2.010122537612915, "percent_done": 5.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139456272125244, "wps": 5536.871365159185, "avg_wps": 1769.0381189621935, "eta_in_seconds": 17448.722935438156, "at": "2024-05-25T22:04:41.383339"} +{"lr": 5.99835977858369e-05, "step": 30, "loss": 1.865985631942749, "percent_done": 6.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5533.739832727509, "avg_wps": 1810.0859077694442, "eta_in_seconds": 17016.827691872917, "at": "2024-05-25T22:04:53.227570"} +{"lr": 5.9976381758692166e-05, "step": 31, "loss": 1.4043118953704834, "percent_done": 6.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5532.196994566016, "avg_wps": 1850.242670335246, "eta_in_seconds": 16612.082562354302, "at": "2024-05-25T22:05:05.075097"} +{"lr": 5.9967854472748474e-05, "step": 32, "loss": 1.771388053894043, "percent_done": 6.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13995599746704, "wps": 5528.366398008164, "avg_wps": 1889.5282279310034, "eta_in_seconds": 16232.013656437397, "at": "2024-05-25T22:05:16.930835"} +{"lr": 5.9958016301016944e-05, "step": 33, "loss": 1.6079459190368652, "percent_done": 6.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1399564743042, "wps": 5530.096007165038, "avg_wps": 1927.9898190231859, "eta_in_seconds": 15874.208306507631, "at": "2024-05-25T22:05:28.782877"} +{"lr": 5.994686767385109e-05, "step": 34, "loss": 1.8389538526535034, "percent_done": 6.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5548.02575516183, "avg_wps": 1965.7136464029804, "eta_in_seconds": 15536.228308677673, "at": "2024-05-25T22:05:40.596542"} +{"lr": 5.993440907892797e-05, "step": 35, "loss": 1.840371012687683, "percent_done": 7.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139039993286133, "wps": 5546.35485799353, "avg_wps": 2002.6531319906146, "eta_in_seconds": 15216.933733156748, "at": "2024-05-25T22:05:52.413778"} +{"lr": 5.9920641061226885e-05, "step": 36, "loss": 1.7521817684173584, "percent_done": 7.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14044427871704, "wps": 5540.577621386599, "avg_wps": 2038.8165240629946, "eta_in_seconds": 14914.880098872714, "at": "2024-05-25T22:06:04.243314"} +{"lr": 5.9905564223005546e-05, "step": 37, "loss": 1.7343847751617432, "percent_done": 7.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5543.818420816132, "avg_wps": 2074.2603671670677, "eta_in_seconds": 14628.42779059668, "at": "2024-05-25T22:06:16.065952"} +{"lr": 5.988917922377368e-05, "step": 38, "loss": 1.3425891399383545, "percent_done": 7.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5548.527579044411, "avg_wps": 2109.012464386962, "eta_in_seconds": 14356.307756009855, "at": "2024-05-25T22:06:27.878578"} +{"lr": 5.9871486780264246e-05, "step": 39, "loss": 1.4163566827774048, "percent_done": 7.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5535.693754583073, "avg_wps": 2143.0270116881056, "eta_in_seconds": 14097.86056602307, "at": "2024-05-25T22:06:39.718619"} +{"lr": 5.985248766640204e-05, "step": 40, "loss": 1.7220834493637085, "percent_done": 8.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5536.443348739875, "avg_wps": 2176.3758096566335, "eta_in_seconds": 13851.725362062454, "at": "2024-05-25T22:06:51.557025"} +{"lr": 5.983218271326983e-05, "step": 41, "loss": 1.53286612033844, "percent_done": 8.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5537.267880265823, "avg_wps": 2209.078717214353, "eta_in_seconds": 13616.999596072406, "at": "2024-05-25T22:07:03.393696"} +{"lr": 5.981057280907208e-05, "step": 42, "loss": 1.1175395250320435, "percent_done": 8.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1409330368042, "wps": 5529.745793791417, "avg_wps": 2241.1219532407085, "eta_in_seconds": 13393.063218446006, "at": "2024-05-25T22:07:15.246432"} +{"lr": 5.978765889909597e-05, "step": 43, "loss": 1.2107163667678833, "percent_done": 8.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5545.109448641502, "avg_wps": 2272.6128681348164, "eta_in_seconds": 13178.642266766969, "at": "2024-05-25T22:07:27.066384"} +{"lr": 5.976344198567018e-05, "step": 44, "loss": 1.7663185596466064, "percent_done": 8.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5540.493975321999, "avg_wps": 2303.4910422531702, "eta_in_seconds": 12973.532543355768, "at": "2024-05-25T22:07:38.896115"} +{"lr": 5.9737923128120935e-05, "step": 45, "loss": 1.2885420322418213, "percent_done": 9.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5531.567432399225, "avg_wps": 2333.7558908646724, "eta_in_seconds": 12777.20609800021, "at": "2024-05-25T22:07:50.744945"} +{"lr": 5.971110344272575e-05, "step": 46, "loss": 1.4329020977020264, "percent_done": 9.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5526.3755346328535, "avg_wps": 2363.4378901504992, "eta_in_seconds": 12589.010324322659, "at": "2024-05-25T22:08:02.604890"} +{"lr": 5.968298410266454e-05, "step": 47, "loss": 1.9799071550369263, "percent_done": 9.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13873529434204, "wps": 5539.442863470415, "avg_wps": 2392.6250525446417, "eta_in_seconds": 12408.04862777223, "at": "2024-05-25T22:08:14.436901"} +{"lr": 5.9653566337968336e-05, "step": 48, "loss": 1.4268672466278076, "percent_done": 9.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13966703414917, "wps": 5538.246974814324, "avg_wps": 2421.2758848761755, "eta_in_seconds": 12234.158108552298, "at": "2024-05-25T22:08:26.271483"} +{"lr": 5.9622851435465466e-05, "step": 49, "loss": 1.9112210273742676, "percent_done": 9.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13922357559204, "wps": 5520.597025623152, "avg_wps": 2449.338834708171, "eta_in_seconds": 12067.230381182262, "at": "2024-05-25T22:08:38.143905"} +{"lr": 5.9590840738725265e-05, "step": 50, "loss": 1.664664387702942, "percent_done": 10.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13933753967285, "wps": 5540.159639641797, "avg_wps": 2476.976633654808, "eta_in_seconds": 11906.127655506134, "at": "2024-05-25T22:08:49.974438"} +{"lr": 5.955753564799931e-05, "step": 51, "loss": 1.698335886001587, "percent_done": 10.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13935899734497, "wps": 5542.056753488515, "avg_wps": 2504.1321414867934, "eta_in_seconds": 11750.843141420215, "at": "2024-05-25T22:09:01.800838"} +{"lr": 5.9522937620160167e-05, "step": 52, "loss": 1.842172384262085, "percent_done": 10.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5536.226912269592, "avg_wps": 2530.7872951936006, "eta_in_seconds": 11601.183574676514, "at": "2024-05-25T22:09:13.639853"} +{"lr": 5.9487048168637646e-05, "step": 53, "loss": 1.6874887943267822, "percent_done": 10.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14142084121704, "wps": 5519.104502091987, "avg_wps": 2556.9087546851515, "eta_in_seconds": 11457.034572048007, "at": "2024-05-25T22:09:25.515428"} +{"lr": 5.944986886335264e-05, "step": 54, "loss": 1.5346497297286987, "percent_done": 10.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13853931427002, "wps": 5529.741010370717, "avg_wps": 2582.6205532103518, "eta_in_seconds": 11317.59598353174, "at": "2024-05-25T22:09:37.368175"} +{"lr": 5.941140133064838e-05, "step": 55, "loss": 1.6654815673828125, "percent_done": 11.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5533.699839270242, "avg_wps": 2607.9074046690016, "eta_in_seconds": 11182.72832378474, "at": "2024-05-25T22:09:49.212434"} +{"lr": 5.937164725321938e-05, "step": 56, "loss": 1.5459319353103638, "percent_done": 11.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5534.284759400332, "avg_wps": 2632.76695202972, "eta_in_seconds": 11052.244475177356, "at": "2024-05-25T22:10:01.055467"} +{"lr": 5.933060837003778e-05, "step": 57, "loss": 1.263810634613037, "percent_done": 11.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14113140106201, "wps": 5524.281408249896, "avg_wps": 2657.167163803352, "eta_in_seconds": 10926.09015928235, "at": "2024-05-25T22:10:12.919993"} +{"lr": 5.928828647627726e-05, "step": 58, "loss": 1.76726496219635, "percent_done": 11.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5539.613667125813, "avg_wps": 2681.221114413725, "eta_in_seconds": 10803.626692434837, "at": "2024-05-25T22:10:24.751609"} +{"lr": 5.924468342323457e-05, "step": 59, "loss": 1.5752986669540405, "percent_done": 11.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5525.510591862112, "avg_wps": 2704.819793975247, "eta_in_seconds": 10685.139196472654, "at": "2024-05-25T22:10:36.613443"} +{"lr": 5.919980111824851e-05, "step": 60, "loss": 1.4939701557159424, "percent_done": 12.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1409330368042, "wps": 5526.555978097075, "avg_wps": 2728.0343519292246, "eta_in_seconds": 10570.189477125803, "at": "2024-05-25T22:10:48.473005"} +{"lr": 5.915364152461648e-05, "step": 61, "loss": 1.3114984035491943, "percent_done": 12.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5532.251886264102, "avg_wps": 2750.893163305559, "eta_in_seconds": 10458.531935652749, "at": "2024-05-25T22:11:00.320352"} +{"lr": 5.9106206661508645e-05, "step": 62, "loss": 1.5468474626541138, "percent_done": 12.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139453887939453, "wps": 5532.953660697286, "avg_wps": 2773.3851612342896, "eta_in_seconds": 10350.083501285122, "at": "2024-05-25T22:11:12.166197"} +{"lr": 5.90574986038796e-05, "step": 63, "loss": 1.3879033327102661, "percent_done": 12.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5537.726146236248, "avg_wps": 2795.535717326603, "eta_in_seconds": 10244.631046026472, "at": "2024-05-25T22:11:24.001887"} +{"lr": 5.9007519482377565e-05, "step": 64, "loss": 1.4439136981964111, "percent_done": 12.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5534.993736920034, "avg_wps": 2817.323056344394, "eta_in_seconds": 10142.143953159451, "at": "2024-05-25T22:11:35.843333"} +{"lr": 5.8956271483251227e-05, "step": 65, "loss": 1.567832112312317, "percent_done": 13.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5533.965544802702, "avg_wps": 2838.7624119314255, "eta_in_seconds": 10042.46071463365, "at": "2024-05-25T22:11:47.687056"} +{"lr": 5.8903756848254094e-05, "step": 66, "loss": 1.8967957496643066, "percent_done": 13.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5537.435314807347, "avg_wps": 2859.880056007073, "eta_in_seconds": 9945.390520926678, "at": "2024-05-25T22:11:59.523357"} +{"lr": 5.884997787454641e-05, "step": 67, "loss": 1.7465324401855469, "percent_done": 13.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1411771774292, "wps": 5538.385678118816, "avg_wps": 2880.6736048710677, "eta_in_seconds": 9850.85153417445, "at": "2024-05-25T22:12:11.357630"} +{"lr": 5.879493691459472e-05, "step": 68, "loss": 1.7675424814224243, "percent_done": 13.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5532.369133234906, "avg_wps": 2901.122491159192, "eta_in_seconds": 9758.82682867611, "at": "2024-05-25T22:12:23.204732"} +{"lr": 5.873863637606892e-05, "step": 69, "loss": 1.8643747568130493, "percent_done": 13.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139580726623535, "wps": 5531.476934181323, "avg_wps": 2921.2547968484523, "eta_in_seconds": 9669.138080824976, "at": "2024-05-25T22:12:35.053733"} +{"lr": 5.868107872173695e-05, "step": 70, "loss": 2.0621795654296875, "percent_done": 14.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13907241821289, "wps": 5528.966761520842, "avg_wps": 2941.0711223561316, "eta_in_seconds": 9581.706401382175, "at": "2024-05-25T22:12:46.908150"} +{"lr": 5.862226646935706e-05, "step": 71, "loss": 1.7251265048980713, "percent_done": 14.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.141066551208496, "wps": 5535.076659704005, "avg_wps": 2960.6131930519027, "eta_in_seconds": 9496.324635038913, "at": "2024-05-25T22:12:58.749481"} +{"lr": 5.856220219156771e-05, "step": 72, "loss": 1.6062341928482056, "percent_done": 14.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5538.399515354115, "avg_wps": 2979.8763909947434, "eta_in_seconds": 9412.943464623559, "at": "2024-05-25T22:13:10.583721"} +{"lr": 5.8500888515774985e-05, "step": 73, "loss": 1.569394826889038, "percent_done": 14.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5535.043891532772, "avg_wps": 2998.840340494905, "eta_in_seconds": 9331.56447914855, "at": "2024-05-25T22:13:22.425119"} +{"lr": 5.84383281240377e-05, "step": 74, "loss": 1.465248703956604, "percent_done": 14.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5533.697054232073, "avg_wps": 3017.5194597715245, "eta_in_seconds": 9252.081510060543, "at": "2024-05-25T22:13:34.269418"} +{"lr": 5.8374523752950034e-05, "step": 75, "loss": 1.4536652565002441, "percent_done": 15.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5547.902132953314, "avg_wps": 3035.982166299971, "eta_in_seconds": 9174.230438232422, "at": "2024-05-25T22:13:46.083424"} +{"lr": 5.830947819352191e-05, "step": 76, "loss": 1.9199892282485962, "percent_done": 15.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5523.671294926767, "avg_wps": 3054.0803565473693, "eta_in_seconds": 9098.406314172244, "at": "2024-05-25T22:13:57.949194"} +{"lr": 5.8243194291056786e-05, "step": 77, "loss": 1.7800021171569824, "percent_done": 15.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13897943496704, "wps": 5538.398064672976, "avg_wps": 3071.976113690907, "eta_in_seconds": 9024.07016657854, "at": "2024-05-25T22:14:09.783429"} +{"lr": 5.817567494502731e-05, "step": 78, "loss": 1.5275590419769287, "percent_done": 15.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13873529434204, "wps": 5535.078220102789, "avg_wps": 3089.602637728104, "eta_in_seconds": 8951.37506107795, "at": "2024-05-25T22:14:21.638665"} +{"lr": 5.810692310894839e-05, "step": 79, "loss": 1.35567307472229, "percent_done": 15.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14020013809204, "wps": 5519.279262417243, "avg_wps": 3106.915483279532, "eta_in_seconds": 8880.401204501526, "at": "2024-05-25T22:14:33.513860"} +{"lr": 5.8036941790248074e-05, "step": 80, "loss": 1.568904995918274, "percent_done": 16.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14093255996704, "wps": 5518.295230159511, "avg_wps": 3123.9794050907803, "eta_in_seconds": 8810.91596031189, "at": "2024-05-25T22:14:45.391215"} +{"lr": 5.796573405013595e-05, "step": 81, "loss": 1.6607871055603027, "percent_done": 16.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1388578414917, "wps": 5535.235156131349, "avg_wps": 3140.8710634908134, "eta_in_seconds": 8742.665154003804, "at": "2024-05-25T22:14:57.232186"} +{"lr": 5.7893303003469235e-05, "step": 82, "loss": 1.8185405731201172, "percent_done": 16.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14020013809204, "wps": 5531.238180032508, "avg_wps": 3157.511832033713, "eta_in_seconds": 8675.833839189714, "at": "2024-05-25T22:15:09.081719"} +{"lr": 5.7819651818616575e-05, "step": 83, "loss": 1.7938737869262695, "percent_done": 16.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5538.24318093579, "avg_wps": 3173.9502642027755, "eta_in_seconds": 8610.252122795726, "at": "2024-05-25T22:15:20.916268"} +{"lr": 5.774478371731938e-05, "step": 84, "loss": 1.3827170133590698, "percent_done": 16.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5526.76199138343, "avg_wps": 3190.1178006375894, "eta_in_seconds": 8546.071870622181, "at": "2024-05-25T22:15:32.775405"} +{"lr": 5.766870197455095e-05, "step": 85, "loss": 1.6816377639770508, "percent_done": 17.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5531.788180325271, "avg_wps": 3206.084541058031, "eta_in_seconds": 8483.070128595127, "at": "2024-05-25T22:15:44.623825"} +{"lr": 5.759140991837317e-05, "step": 86, "loss": 1.3680201768875122, "percent_done": 17.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5525.592675365883, "avg_wps": 3221.81055226947, "eta_in_seconds": 8421.321974033533, "at": "2024-05-25T22:15:56.485525"} +{"lr": 5.751291092979098e-05, "step": 87, "loss": 1.7220127582550049, "percent_done": 17.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13897943496704, "wps": 5535.422086578825, "avg_wps": 3237.3634711881114, "eta_in_seconds": 8360.620684357895, "at": "2024-05-25T22:16:08.326192"} +{"lr": 5.743320844260443e-05, "step": 88, "loss": 1.316036343574524, "percent_done": 17.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5536.561107992587, "avg_wps": 3252.713150271047, "eta_in_seconds": 8301.018489057367, "at": "2024-05-25T22:16:20.164363"} +{"lr": 5.735230594325853e-05, "step": 89, "loss": 1.5626420974731445, "percent_done": 17.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5528.980774154521, "avg_wps": 3267.8295242257354, "eta_in_seconds": 8242.564613703931, "at": "2024-05-25T22:16:32.018795"} +{"lr": 5.727020697069067e-05, "step": 90, "loss": 1.6677188873291016, "percent_done": 18.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14020013809204, "wps": 5529.578712697917, "avg_wps": 3282.748793053368, "eta_in_seconds": 8185.140470345815, "at": "2024-05-25T22:16:43.871913"} +{"lr": 5.718691511617588e-05, "step": 91, "loss": 1.5478179454803467, "percent_done": 18.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13849115371704, "wps": 5531.183419749006, "avg_wps": 3297.4787956632053, "eta_in_seconds": 8128.702460574579, "at": "2024-05-25T22:16:55.721611"} +{"lr": 5.7102434023169716e-05, "step": 92, "loss": 1.4003026485443115, "percent_done": 18.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13897943496704, "wps": 5498.951573208651, "avg_wps": 3311.890707400976, "eta_in_seconds": 8073.541780907175, "at": "2024-05-25T22:17:07.640749"} +{"lr": 5.701676738714885e-05, "step": 93, "loss": 1.3452470302581787, "percent_done": 18.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5526.587645807131, "avg_wps": 3326.223331155903, "eta_in_seconds": 8019.050239398915, "at": "2024-05-25T22:17:19.500291"} +{"lr": 5.6929918955449466e-05, "step": 94, "loss": 1.50814950466156, "percent_done": 18.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5536.120651613291, "avg_wps": 3340.408623531156, "eta_in_seconds": 7965.377592599139, "at": "2024-05-25T22:17:31.339417"} +{"lr": 5.6841892527103325e-05, "step": 95, "loss": 1.449243187904358, "percent_done": 19.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5534.185815649729, "avg_wps": 3354.4054872665934, "eta_in_seconds": 7912.603321439342, "at": "2024-05-25T22:17:43.182648"} +{"lr": 5.675269195267157e-05, "step": 96, "loss": 1.5438588857650757, "percent_done": 19.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14142084121704, "wps": 5518.593693577431, "avg_wps": 3368.1645443526363, "eta_in_seconds": 7860.822608679533, "at": "2024-05-25T22:17:55.059376"} +{"lr": 5.6662321134076275e-05, "step": 97, "loss": 1.4851049184799194, "percent_done": 19.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14044427871704, "wps": 5531.843397891452, "avg_wps": 3381.800928535651, "eta_in_seconds": 7809.74651025251, "at": "2024-05-25T22:18:06.907604"} +{"lr": 5.657078402442983e-05, "step": 98, "loss": 1.485952377319336, "percent_done": 19.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5536.484273972819, "avg_wps": 3395.2843297455797, "eta_in_seconds": 7759.43026897372, "at": "2024-05-25T22:18:18.745900"} +{"lr": 5.6478084627861946e-05, "step": 99, "loss": 1.4768633842468262, "percent_done": 19.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5521.5026874343275, "avg_wps": 3408.5425154087948, "eta_in_seconds": 7710.021477273017, "at": "2024-05-25T22:18:30.616325"} +{"lr": 5.638422699934453e-05, "step": 100, "loss": 1.587773084640503, "percent_done": 20.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.138602256774902, "wps": 5527.2304120796, "avg_wps": 3421.6583539038124, "eta_in_seconds": 7661.314277648926, "at": "2024-05-25T22:18:42.474456"} +{"lr": 5.62892152445143e-05, "step": 101, "loss": 1.4422743320465088, "percent_done": 20.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1399564743042, "wps": 5599.027294895566, "avg_wps": 3434.8837934325293, "eta_in_seconds": 7612.736142630624, "at": "2024-05-25T22:19:08.929106"} +{"lr": 5.619305351949323e-05, "step": 102, "loss": 1.6620022058486938, "percent_done": 20.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5550.775309031288, "avg_wps": 3447.768593583235, "eta_in_seconds": 7565.278031868093, "at": "2024-05-25T22:19:20.736985"} +{"lr": 5.609574603070667e-05, "step": 103, "loss": 1.7876899242401123, "percent_done": 20.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5548.168756200814, "avg_wps": 3460.4875784576047, "eta_in_seconds": 7518.533562139401, "at": "2024-05-25T22:19:32.550395"} +{"lr": 5.599729703469942e-05, "step": 104, "loss": 1.6648534536361694, "percent_done": 20.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13893413543701, "wps": 5536.105487780869, "avg_wps": 3473.0079000580445, "eta_in_seconds": 7472.558873121555, "at": "2024-05-25T22:19:44.389502"} +{"lr": 5.589771083794951e-05, "step": 105, "loss": 1.4844549894332886, "percent_done": 21.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5532.074744759462, "avg_wps": 3485.3628532805133, "eta_in_seconds": 7427.266855625879, "at": "2024-05-25T22:19:56.237238"} +{"lr": 5.579699179667977e-05, "step": 106, "loss": 1.725979208946228, "percent_done": 21.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13897943496704, "wps": 5507.068846778387, "avg_wps": 3497.4757031259414, "eta_in_seconds": 7382.805826762938, "at": "2024-05-25T22:20:08.138792"} +{"lr": 5.569514431666738e-05, "step": 107, "loss": 1.2329559326171875, "percent_done": 21.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 3116.60980459032, "avg_wps": 3493.4857769672835, "eta_in_seconds": 7372.478276513448, "at": "2024-05-25T22:20:29.167841"} +{"lr": 5.559217285305104e-05, "step": 108, "loss": 1.6703511476516724, "percent_done": 21.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5559.812583536628, "avg_wps": 3505.5492170397974, "eta_in_seconds": 7328.4128704071045, "at": "2024-05-25T22:20:40.956426"} +{"lr": 5.548808191013616e-05, "step": 109, "loss": 1.4362456798553467, "percent_done": 21.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.141066074371338, "wps": 5537.786391318181, "avg_wps": 3517.391417086075, "eta_in_seconds": 7285.107899998306, "at": "2024-05-25T22:20:52.791888"} +{"lr": 5.538287604119777e-05, "step": 110, "loss": 1.3590904474258423, "percent_done": 22.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13897943496704, "wps": 5522.457796593279, "avg_wps": 3529.0396541955142, "eta_in_seconds": 7242.491585384715, "at": "2024-05-25T22:21:04.660314"} +{"lr": 5.5276559848281426e-05, "step": 111, "loss": 1.4913303852081299, "percent_done": 22.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13857650756836, "wps": 5542.21944924541, "avg_wps": 3540.6262525175707, "eta_in_seconds": 7200.281018611548, "at": "2024-05-25T22:21:16.486296"} +{"lr": 5.516913798200181e-05, "step": 112, "loss": 1.6864898204803467, "percent_done": 22.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5533.368550797568, "avg_wps": 3552.0477306393095, "eta_in_seconds": 7158.6785787429135, "at": "2024-05-25T22:21:28.331246"} +{"lr": 5.506061514133933e-05, "step": 113, "loss": 1.7275524139404297, "percent_done": 22.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139621257781982, "wps": 5526.840889427636, "avg_wps": 3563.3150454863935, "eta_in_seconds": 7117.650748318275, "at": "2024-05-25T22:21:40.190190"} +{"lr": 5.495099607343464e-05, "step": 114, "loss": 1.4053714275360107, "percent_done": 22.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5540.172704106169, "avg_wps": 3574.5033157661283, "eta_in_seconds": 7077.038056846251, "at": "2024-05-25T22:21:52.020570"} +{"lr": 5.4840285573380864e-05, "step": 115, "loss": 1.5559868812561035, "percent_done": 23.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5544.330666818346, "avg_wps": 3585.5807890519436, "eta_in_seconds": 7036.896247614985, "at": "2024-05-25T22:22:03.842237"} +{"lr": 5.4728488484013935e-05, "step": 116, "loss": 1.700688362121582, "percent_done": 23.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5527.996614961164, "avg_wps": 3596.4749425207824, "eta_in_seconds": 6997.35835844895, "at": "2024-05-25T22:22:15.698614"} +{"lr": 5.46156096957007e-05, "step": 117, "loss": 1.8308873176574707, "percent_done": 23.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5538.991233443881, "avg_wps": 3607.28751143355, "eta_in_seconds": 6958.216643514796, "at": "2024-05-25T22:22:27.531521"} +{"lr": 5.450165414612506e-05, "step": 118, "loss": 1.7806788682937622, "percent_done": 23.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5524.7541833277655, "avg_wps": 3617.92876689174, "eta_in_seconds": 6919.636513879745, "at": "2024-05-25T22:22:39.395007"} +{"lr": 5.43866268200719e-05, "step": 119, "loss": 1.4693626165390015, "percent_done": 23.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1409330368042, "wps": 5528.15726327424, "avg_wps": 3628.464891399468, "eta_in_seconds": 6881.482044702819, "at": "2024-05-25T22:22:51.251098"} +{"lr": 5.42705327492091e-05, "step": 120, "loss": 1.557875394821167, "percent_done": 24.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5535.1552380218445, "avg_wps": 3638.91066261737, "eta_in_seconds": 6843.718439102173, "at": "2024-05-25T22:23:03.092310"} +{"lr": 5.415337701186742e-05, "step": 121, "loss": 1.5516443252563477, "percent_done": 24.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.140570163726807, "wps": 5530.38495546787, "avg_wps": 3649.225452978279, "eta_in_seconds": 6806.415311974927, "at": "2024-05-25T22:23:14.943580"} +{"lr": 5.403516473281833e-05, "step": 122, "loss": 1.649458885192871, "percent_done": 24.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5534.151609567946, "avg_wps": 3659.441862890493, "eta_in_seconds": 6769.504456735048, "at": "2024-05-25T22:23:26.786920"} +{"lr": 5.391590108304989e-05, "step": 123, "loss": 1.552938461303711, "percent_done": 24.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.140043258666992, "wps": 5524.233557884312, "avg_wps": 3669.5126071461127, "eta_in_seconds": 6733.066389221486, "at": "2024-05-25T22:23:38.651487"} +{"lr": 5.3795591279540496e-05, "step": 124, "loss": 1.5583155155181885, "percent_done": 24.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139499187469482, "wps": 5528.478365530576, "avg_wps": 3679.490337371718, "eta_in_seconds": 6696.997067697587, "at": "2024-05-25T22:23:50.506940"} +{"lr": 5.3674240585030686e-05, "step": 125, "loss": 1.4841161966323853, "percent_done": 25.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5528.541856577655, "avg_wps": 3689.3617575612607, "eta_in_seconds": 6661.314778804778, "at": "2024-05-25T22:24:02.362356"} +{"lr": 5.3551854307792975e-05, "step": 126, "loss": 1.5494056940078735, "percent_done": 25.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5523.731345589434, "avg_wps": 3699.1112305221154, "eta_in_seconds": 6626.041357653481, "at": "2024-05-25T22:24:14.227903"} +{"lr": 5.3428437801399596e-05, "step": 127, "loss": 1.463014006614685, "percent_done": 25.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5531.165834359518, "avg_wps": 3708.7839713260078, "eta_in_seconds": 6591.089745046585, "at": "2024-05-25T22:24:26.077518"} +{"lr": 5.3303996464488364e-05, "step": 128, "loss": 1.713060975074768, "percent_done": 25.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5535.1767499219595, "avg_wps": 3718.369260831204, "eta_in_seconds": 6556.474166460335, "at": "2024-05-25T22:24:37.918589"} +{"lr": 5.317853574052649e-05, "step": 129, "loss": 1.561232089996338, "percent_done": 25.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14098072052002, "wps": 5528.585111383596, "avg_wps": 3727.8312598566954, "eta_in_seconds": 6522.252297689748, "at": "2024-05-25T22:24:49.773921"} +{"lr": 5.3052061117572476e-05, "step": 130, "loss": 1.5533205270767212, "percent_done": 26.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1409330368042, "wps": 5523.546868781365, "avg_wps": 3737.1771322003938, "eta_in_seconds": 6488.405323652121, "at": "2024-05-25T22:25:01.639827"} +{"lr": 5.292457812803603e-05, "step": 131, "loss": 1.6568609476089478, "percent_done": 26.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5528.329261817617, "avg_wps": 3746.4430065582296, "eta_in_seconds": 6454.865043367138, "at": "2024-05-25T22:25:13.495524"} +{"lr": 5.2796092348436136e-05, "step": 132, "loss": 1.3584004640579224, "percent_done": 26.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13897943496704, "wps": 5516.80550091994, "avg_wps": 3755.573133584753, "eta_in_seconds": 6421.722368905038, "at": "2024-05-25T22:25:25.375968"} +{"lr": 5.266660939915699e-05, "step": 133, "loss": 1.4305424690246582, "percent_done": 26.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5530.349572420729, "avg_wps": 3764.656876385959, "eta_in_seconds": 6388.819164600587, "at": "2024-05-25T22:25:37.227363"} +{"lr": 5.25361349442023e-05, "step": 134, "loss": 1.5304365158081055, "percent_done": 26.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5522.819848235018, "avg_wps": 3773.621908271301, "eta_in_seconds": 6356.274312332494, "at": "2024-05-25T22:25:49.095116"} +{"lr": 5.240467469094738e-05, "step": 135, "loss": 1.8120039701461792, "percent_done": 27.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139307498931885, "wps": 5535.127707492048, "avg_wps": 3782.538646915194, "eta_in_seconds": 6323.964467490161, "at": "2024-05-25T22:26:00.936199"} +{"lr": 5.227223438988959e-05, "step": 136, "loss": 1.4749547243118286, "percent_done": 27.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5489.787344893303, "avg_wps": 3791.2078655688274, "eta_in_seconds": 6292.217373953146, "at": "2024-05-25T22:26:12.875129"} +{"lr": 5.2138819834396735e-05, "step": 137, "loss": 1.613757610321045, "percent_done": 27.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5525.56635062068, "avg_wps": 3799.9137971247605, "eta_in_seconds": 6260.5546520556845, "at": "2024-05-25T22:26:24.736742"} +{"lr": 5.200443686045369e-05, "step": 138, "loss": 1.5715901851654053, "percent_done": 27.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5523.934040091993, "avg_wps": 3808.5271421746756, "eta_in_seconds": 6229.188112455866, "at": "2024-05-25T22:26:36.601900"} +{"lr": 5.1869091346407056e-05, "step": 139, "loss": 1.4897774457931519, "percent_done": 27.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5534.811850483233, "avg_wps": 3817.0921429157083, "eta_in_seconds": 6198.041628077734, "at": "2024-05-25T22:26:48.443835"} +{"lr": 5.1732789212708097e-05, "step": 140, "loss": 1.5047266483306885, "percent_done": 28.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5532.469348260165, "avg_wps": 3825.5645754605275, "eta_in_seconds": 6167.183832509177, "at": "2024-05-25T22:27:00.290624"} +{"lr": 5.159553642165368e-05, "step": 141, "loss": 1.8195000886917114, "percent_done": 28.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5537.891488654509, "avg_wps": 3833.972176303514, "eta_in_seconds": 6136.566182043535, "at": "2024-05-25T22:27:12.125840"} +{"lr": 5.145733897712554e-05, "step": 142, "loss": 1.4714698791503906, "percent_done": 28.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13897943496704, "wps": 5524.16039616699, "avg_wps": 3842.250953086935, "eta_in_seconds": 6106.287248403254, "at": "2024-05-25T22:27:23.990534"} +{"lr": 5.131820292432759e-05, "step": 143, "loss": 1.49951171875, "percent_done": 28.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5527.2720903651525, "avg_wps": 3850.459589909883, "eta_in_seconds": 6076.249199267034, "at": "2024-05-25T22:27:35.848480"} +{"lr": 5.117813434952152e-05, "step": 144, "loss": 1.6421213150024414, "percent_done": 28.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5532.893966195105, "avg_wps": 3858.6076442062945, "eta_in_seconds": 6046.433882706696, "at": "2024-05-25T22:27:47.694640"} +{"lr": 5.103713937976054e-05, "step": 145, "loss": 1.5833499431610107, "percent_done": 29.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14060688018799, "wps": 5534.089215198446, "avg_wps": 3866.681181611136, "eta_in_seconds": 6016.860172140187, "at": "2024-05-25T22:27:59.538005"} +{"lr": 5.0895224182621414e-05, "step": 146, "loss": 1.7415547370910645, "percent_done": 29.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5538.220864108457, "avg_wps": 3874.69114727732, "eta_in_seconds": 5987.507937581572, "at": "2024-05-25T22:28:11.372536"} +{"lr": 5.075239496593458e-05, "step": 147, "loss": 1.363211989402771, "percent_done": 29.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5525.6680965942705, "avg_wps": 3882.5826477907335, "eta_in_seconds": 5958.458608257528, "at": "2024-05-25T22:28:23.233990"} +{"lr": 5.0608657977512685e-05, "step": 148, "loss": 1.411226749420166, "percent_done": 29.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5536.754484904988, "avg_wps": 3890.4361239585437, "eta_in_seconds": 5929.585081203564, "at": "2024-05-25T22:28:35.071801"} +{"lr": 5.0464019504877256e-05, "step": 149, "loss": 1.9325288534164429, "percent_done": 29.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5533.476042541659, "avg_wps": 3898.2044675756474, "eta_in_seconds": 5900.956758767967, "at": "2024-05-25T22:28:46.916420"} +{"lr": 5.031848587498364e-05, "step": 150, "loss": 1.431246280670166, "percent_done": 30.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5529.682275088901, "avg_wps": 3905.8870887304815, "eta_in_seconds": 5872.571192900339, "at": "2024-05-25T22:28:58.769256"} +{"lr": 5.017206345394427e-05, "step": 151, "loss": 1.4973747730255127, "percent_done": 30.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1399564743042, "wps": 5526.7336553117175, "avg_wps": 3913.4879082228986, "eta_in_seconds": 5844.419233273197, "at": "2024-05-25T22:29:10.628409"} +{"lr": 5.00247586467502e-05, "step": 152, "loss": 1.4542311429977417, "percent_done": 30.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5532.066951239151, "avg_wps": 3921.035417625128, "eta_in_seconds": 5816.455494761467, "at": "2024-05-25T22:29:22.476201"} +{"lr": 4.987657789699088e-05, "step": 153, "loss": 1.8025246858596802, "percent_done": 30.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5539.373986806565, "avg_wps": 3928.5369174809694, "eta_in_seconds": 5788.666996817184, "at": "2024-05-25T22:29:34.308481"} +{"lr": 4.9727527686572356e-05, "step": 154, "loss": 1.5920372009277344, "percent_done": 30.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5535.196032751744, "avg_wps": 3935.9554873862685, "eta_in_seconds": 5761.105803322482, "at": "2024-05-25T22:29:46.149494"} +{"lr": 4.957761453543368e-05, "step": 155, "loss": 1.2139917612075806, "percent_done": 31.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5527.079264103846, "avg_wps": 3943.2792474493085, "eta_in_seconds": 5733.786166583338, "at": "2024-05-25T22:29:58.007926"} +{"lr": 4.942684500126173e-05, "step": 156, "loss": 1.8046396970748901, "percent_done": 31.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5534.837929054387, "avg_wps": 3950.5612688475035, "eta_in_seconds": 5706.628113269806, "at": "2024-05-25T22:30:09.849705"} +{"lr": 4.927522567920438e-05, "step": 157, "loss": 1.65402090549469, "percent_done": 31.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13886022567749, "wps": 5522.012592526507, "avg_wps": 3957.7350910627347, "eta_in_seconds": 5679.7252678081495, "at": "2024-05-25T22:30:21.718994"} +{"lr": 4.9122763201581924e-05, "step": 158, "loss": 1.6110213994979858, "percent_done": 31.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5525.584233648117, "avg_wps": 3964.855358902498, "eta_in_seconds": 5652.996130028858, "at": "2024-05-25T22:30:33.580731"} +{"lr": 4.8969464237597066e-05, "step": 159, "loss": 1.2890688180923462, "percent_done": 31.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5540.148585143146, "avg_wps": 3971.9584529639815, "eta_in_seconds": 5626.387149977234, "at": "2024-05-25T22:30:45.411148"} +{"lr": 4.8815335493043095e-05, "step": 160, "loss": 1.5860767364501953, "percent_done": 32.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5525.745852593415, "avg_wps": 3978.951224212477, "eta_in_seconds": 5600.028435736895, "at": "2024-05-25T22:30:57.272398"} +{"lr": 4.866038371001062e-05, "step": 161, "loss": 1.0712507963180542, "percent_done": 32.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139376640319824, "wps": 5532.372807721712, "avg_wps": 3985.902727249423, "eta_in_seconds": 5573.819914900739, "at": "2024-05-25T22:31:09.119445"} +{"lr": 4.850461566659259e-05, "step": 162, "loss": 1.2214797735214233, "percent_done": 32.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5539.230099270619, "avg_wps": 3992.814312803984, "eta_in_seconds": 5547.758113610892, "at": "2024-05-25T22:31:20.951833"} +{"lr": 4.834803817658786e-05, "step": 163, "loss": 1.8359795808792114, "percent_done": 32.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5536.410229852604, "avg_wps": 3999.655639904624, "eta_in_seconds": 5521.883379071768, "at": "2024-05-25T22:31:32.790385"} +{"lr": 4.819065808920307e-05, "step": 164, "loss": 1.3456029891967773, "percent_done": 32.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5539.916562513642, "avg_wps": 4006.447781202731, "eta_in_seconds": 5496.164483489059, "at": "2024-05-25T22:31:44.621283"} +{"lr": 4.803248228875308e-05, "step": 165, "loss": 1.512420892715454, "percent_done": 33.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5544.381661777678, "avg_wps": 4013.1944720073416, "eta_in_seconds": 5470.594598177708, "at": "2024-05-25T22:31:56.442753"} +{"lr": 4.7873517694359834e-05, "step": 166, "loss": 1.333431363105774, "percent_done": 33.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13935899734497, "wps": 5543.356127668449, "avg_wps": 4019.8789796635306, "eta_in_seconds": 5445.194770970977, "at": "2024-05-25T22:32:08.266379"} +{"lr": 4.7713771259649654e-05, "step": 167, "loss": 1.384599208831787, "percent_done": 33.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5543.143845234439, "avg_wps": 4026.504668133657, "eta_in_seconds": 5419.95844999616, "at": "2024-05-25T22:32:20.090524"} +{"lr": 4.755324997244911e-05, "step": 168, "loss": 1.3218507766723633, "percent_done": 33.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5539.795311066067, "avg_wps": 4033.0624095732774, "eta_in_seconds": 5394.895935245923, "at": "2024-05-25T22:32:31.921649"} +{"lr": 4.739196085447931e-05, "step": 169, "loss": 1.4310145378112793, "percent_done": 33.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1392240524292, "wps": 5539.7708604503805, "avg_wps": 4039.563484265146, "eta_in_seconds": 5369.990120094909, "at": "2024-05-25T22:32:43.752867"} +{"lr": 4.722991096104879e-05, "step": 170, "loss": 1.3229132890701294, "percent_done": 34.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5522.456576150099, "avg_wps": 4045.9542010776304, "eta_in_seconds": 5345.3101357992955, "at": "2024-05-25T22:32:55.621230"} +{"lr": 4.706710738074485e-05, "step": 171, "loss": 1.4226155281066895, "percent_done": 34.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5533.96075407876, "avg_wps": 4052.3262200198014, "eta_in_seconds": 5320.732544551816, "at": "2024-05-25T22:33:07.464856"} +{"lr": 4.6903557235123503e-05, "step": 172, "loss": 1.5008213520050049, "percent_done": 34.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5538.737433173409, "avg_wps": 4058.6588234779615, "eta_in_seconds": 5296.283559399983, "at": "2024-05-25T22:33:19.298460"} +{"lr": 4.673926767839795e-05, "step": 173, "loss": 1.2238497734069824, "percent_done": 34.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13941717147827, "wps": 5536.440560939478, "avg_wps": 4064.9305437467933, "eta_in_seconds": 5271.989710369551, "at": "2024-05-25T22:33:31.136760"} +{"lr": 4.6574245897125624e-05, "step": 174, "loss": 1.0429325103759766, "percent_done": 34.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5528.988225345801, "avg_wps": 4071.1260646272876, "eta_in_seconds": 5247.868933765368, "at": "2024-05-25T22:33:42.991038"} +{"lr": 4.640849910989384e-05, "step": 175, "loss": 1.3254176378250122, "percent_done": 35.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5534.000528480136, "avg_wps": 4077.284932343515, "eta_in_seconds": 5223.868420634951, "at": "2024-05-25T22:33:54.834594"} +{"lr": 4.6242034567004e-05, "step": 176, "loss": 1.284037470817566, "percent_done": 35.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5522.944241627757, "avg_wps": 4083.3578875268263, "eta_in_seconds": 5200.049710279161, "at": "2024-05-25T22:34:06.725057"} +{"lr": 4.60748595501545e-05, "step": 177, "loss": 1.6696220636367798, "percent_done": 35.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5540.69600331122, "avg_wps": 4089.434842627239, "eta_in_seconds": 5176.296680252431, "at": "2024-05-25T22:34:18.554388"} +{"lr": 4.590698137212215e-05, "step": 178, "loss": 1.2060277462005615, "percent_done": 35.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5528.969653010865, "avg_wps": 4095.4252584140954, "eta_in_seconds": 5152.7230186033785, "at": "2024-05-25T22:34:30.408665"} +{"lr": 4.5738407376442294e-05, "step": 179, "loss": 1.4724308252334595, "percent_done": 35.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13897943496704, "wps": 5499.342895623346, "avg_wps": 4101.274460591106, "eta_in_seconds": 5129.394826448164, "at": "2024-05-25T22:34:42.326808"} +{"lr": 4.5569144937087604e-05, "step": 180, "loss": 1.3961241245269775, "percent_done": 36.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1399564743042, "wps": 5535.978828425462, "avg_wps": 4107.1878988471835, "eta_in_seconds": 5106.053220960829, "at": "2024-05-25T22:34:54.166070"} +{"lr": 4.5399201458145525e-05, "step": 181, "loss": 1.4968873262405396, "percent_done": 36.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5536.853408997794, "avg_wps": 4113.055457033859, "eta_in_seconds": 5082.835429376001, "at": "2024-05-25T22:35:06.003488"} +{"lr": 4.522858437349436e-05, "step": 182, "loss": 1.233327031135559, "percent_done": 36.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5539.635213694547, "avg_wps": 4118.883503565273, "eta_in_seconds": 5059.732323567946, "at": "2024-05-25T22:35:17.835049"} +{"lr": 4.505730114647811e-05, "step": 183, "loss": 1.6046642065048218, "percent_done": 36.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5521.777760493074, "avg_wps": 4124.609852381241, "eta_in_seconds": 5036.818691592399, "at": "2024-05-25T22:35:29.704688"} +{"lr": 4.488535926958002e-05, "step": 184, "loss": 1.260197401046753, "percent_done": 36.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5539.118030681845, "avg_wps": 4130.342207085291, "eta_in_seconds": 5013.961304338082, "at": "2024-05-25T22:35:41.537243"} +{"lr": 4.471276626409479e-05, "step": 185, "loss": 1.5981565713882446, "percent_done": 37.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5541.857642972014, "avg_wps": 4136.036540662585, "eta_in_seconds": 4991.213157099646, "at": "2024-05-25T22:35:53.363964"} +{"lr": 4.45395296797996e-05, "step": 186, "loss": 1.5876941680908203, "percent_done": 37.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5546.001351484951, "avg_wps": 4141.697548283214, "eta_in_seconds": 4968.56754026618, "at": "2024-05-25T22:36:05.181939"} +{"lr": 4.4365657094623857e-05, "step": 187, "loss": 1.6379966735839844, "percent_done": 37.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5537.327446090922, "avg_wps": 4147.287300719299, "eta_in_seconds": 4946.068722184329, "at": "2024-05-25T22:36:17.018276"} +{"lr": 4.419115611431772e-05, "step": 188, "loss": 1.8801261186599731, "percent_done": 37.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139856815338135, "wps": 5523.667742987618, "avg_wps": 4152.791488249696, "eta_in_seconds": 4923.731918121906, "at": "2024-05-25T22:36:28.884026"} +{"lr": 4.401603437211934e-05, "step": 189, "loss": 1.3729376792907715, "percent_done": 37.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.138864517211914, "wps": 5533.013356487571, "avg_wps": 4158.279804016645, "eta_in_seconds": 4901.472955310155, "at": "2024-05-25T22:36:40.729562"} +{"lr": 4.384029952842108e-05, "step": 190, "loss": 1.5538232326507568, "percent_done": 38.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5528.783936523735, "avg_wps": 4163.712029837937, "eta_in_seconds": 4879.338401505822, "at": "2024-05-25T22:36:52.584226"} +{"lr": 4.366395927043427e-05, "step": 191, "loss": 1.683979868888855, "percent_done": 38.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13849115371704, "wps": 5530.42723769031, "avg_wps": 4169.1062533859085, "eta_in_seconds": 4857.305803504914, "at": "2024-05-25T22:37:04.435571"} +{"lr": 4.348702131185308e-05, "step": 192, "loss": 1.6441792249679565, "percent_done": 38.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5537.756045483439, "avg_wps": 4174.479783032736, "eta_in_seconds": 4835.354115749399, "at": "2024-05-25T22:37:16.271069"} +{"lr": 4.3309493392517e-05, "step": 193, "loss": 1.573068380355835, "percent_done": 38.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5541.468848867806, "avg_wps": 4179.82223526197, "eta_in_seconds": 4813.494657803076, "at": "2024-05-25T22:37:28.098659"} +{"lr": 4.313138327807234e-05, "step": 194, "loss": 1.5878041982650757, "percent_done": 38.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5536.753035085491, "avg_wps": 4185.109214607493, "eta_in_seconds": 4791.754521006162, "at": "2024-05-25T22:37:39.936367"} +{"lr": 4.2952698759632504e-05, "step": 195, "loss": 1.5733189582824707, "percent_done": 39.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14044427871704, "wps": 5534.239966858734, "avg_wps": 4190.347769654751, "eta_in_seconds": 4770.124366466815, "at": "2024-05-25T22:37:51.779418"} +{"lr": 4.277344765343719e-05, "step": 196, "loss": 1.3800745010375977, "percent_done": 39.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139386653900146, "wps": 5539.15542358136, "avg_wps": 4195.560201101285, "eta_in_seconds": 4748.577792965636, "at": "2024-05-25T22:38:03.612119"} +{"lr": 4.2593637800510475e-05, "step": 197, "loss": 1.6179745197296143, "percent_done": 39.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5539.640349170898, "avg_wps": 4200.733916607026, "eta_in_seconds": 4727.1282576352805, "at": "2024-05-25T22:38:15.443591"} +{"lr": 4.241327706631782e-05, "step": 198, "loss": 1.4495550394058228, "percent_done": 39.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5515.075784395491, "avg_wps": 4205.7961234189415, "eta_in_seconds": 4705.856256273058, "at": "2024-05-25T22:38:27.327769"} +{"lr": 4.223237334042203e-05, "step": 199, "loss": 1.693682074546814, "percent_done": 39.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13873529434204, "wps": 5534.125760301313, "avg_wps": 4210.8750989645405, "eta_in_seconds": 4684.6167450682005, "at": "2024-05-25T22:38:39.171042"} +{"lr": 4.205093453613813e-05, "step": 200, "loss": 1.4700599908828735, "percent_done": 40.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5537.086290490554, "avg_wps": 4215.9239687641675, "eta_in_seconds": 4663.461709856987, "at": "2024-05-25T22:38:51.007986"} +{"lr": 4.186896859018719e-05, "step": 201, "loss": 1.369512915611267, "percent_done": 40.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.138686656951904, "wps": 5595.435397297564, "avg_wps": 4221.101481224286, "eta_in_seconds": 4642.215802477367, "at": "2024-05-25T22:39:17.079303"} +{"lr": 4.1686483462349175e-05, "step": 202, "loss": 1.2966172695159912, "percent_done": 40.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139472007751465, "wps": 5561.9329520145475, "avg_wps": 4226.145091015676, "eta_in_seconds": 4621.168364881289, "at": "2024-05-25T22:39:28.863491"} +{"lr": 4.1503487135114756e-05, "step": 203, "loss": 1.4266027212142944, "percent_done": 40.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5543.294308093675, "avg_wps": 4231.097586008466, "eta_in_seconds": 4600.2701673355, "at": "2024-05-25T22:39:40.687235"} +{"lr": 4.1319987613336105e-05, "step": 204, "loss": 1.4435640573501587, "percent_done": 40.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5536.516836170746, "avg_wps": 4235.993553334483, "eta_in_seconds": 4579.481945795172, "at": "2024-05-25T22:39:52.525354"} +{"lr": 4.113599292387675e-05, "step": 205, "loss": 1.3507176637649536, "percent_done": 41.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5534.672991802267, "avg_wps": 4240.847654335366, "eta_in_seconds": 4558.786727515662, "at": "2024-05-25T22:40:04.367607"} +{"lr": 4.095151111526049e-05, "step": 206, "loss": 1.550918698310852, "percent_done": 41.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5530.640105119984, "avg_wps": 4245.654075438708, "eta_in_seconds": 4538.189795410749, "at": "2024-05-25T22:40:16.218426"} +{"lr": 4.076655025731926e-05, "step": 207, "loss": 1.2539643049240112, "percent_done": 41.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13878059387207, "wps": 5525.05068056548, "avg_wps": 4250.408842975308, "eta_in_seconds": 4517.694346447497, "at": "2024-05-25T22:40:28.081219"} +{"lr": 4.058111844084018e-05, "step": 208, "loss": 1.5834758281707764, "percent_done": 41.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5535.966006718693, "avg_wps": 4255.159465059896, "eta_in_seconds": 4497.249082469023, "at": "2024-05-25T22:40:39.920649"} +{"lr": 4.0395223777211613e-05, "step": 209, "loss": 1.621875286102295, "percent_done": 41.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5529.24213391026, "avg_wps": 4259.856033280293, "eta_in_seconds": 4476.906226644105, "at": "2024-05-25T22:40:51.774459"} +{"lr": 4.020887439806836e-05, "step": 210, "loss": 1.5037541389465332, "percent_done": 42.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5535.651168833208, "avg_wps": 4264.536236824635, "eta_in_seconds": 4456.625279880705, "at": "2024-05-25T22:41:03.614549"} +{"lr": 4.0022078454935966e-05, "step": 211, "loss": 1.6204335689544678, "percent_done": 42.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5533.3081790277165, "avg_wps": 4269.175620311635, "eta_in_seconds": 4436.431218685132, "at": "2024-05-25T22:41:15.459637"} +{"lr": 3.9834844118874095e-05, "step": 212, "loss": 1.549316167831421, "percent_done": 42.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5531.893272769696, "avg_wps": 4273.777216215136, "eta_in_seconds": 4416.3200478463805, "at": "2024-05-25T22:41:27.307751"} +{"lr": 3.964717958011919e-05, "step": 213, "loss": 1.008284568786621, "percent_done": 42.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5529.038716036724, "avg_wps": 4278.337375397288, "eta_in_seconds": 4396.294716765623, "at": "2024-05-25T22:41:39.161993"} +{"lr": 3.9459093047726116e-05, "step": 214, "loss": 1.1781988143920898, "percent_done": 42.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5528.792610429211, "avg_wps": 4282.863831812949, "eta_in_seconds": 4376.346467234264, "at": "2024-05-25T22:41:51.016714"} +{"lr": 3.92705927492091e-05, "step": 215, "loss": 1.2642954587936401, "percent_done": 43.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1409330368042, "wps": 5524.645253572456, "avg_wps": 4287.346027755422, "eta_in_seconds": 4356.485312611558, "at": "2024-05-25T22:42:02.880291"} +{"lr": 3.908168693018187e-05, "step": 216, "loss": 1.4156056642532349, "percent_done": 43.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5533.407871127302, "avg_wps": 4291.820426712731, "eta_in_seconds": 4336.673520670996, "at": "2024-05-25T22:42:14.725120"} +{"lr": 3.889238385399692e-05, "step": 217, "loss": 1.051167607307434, "percent_done": 43.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5537.368384395405, "avg_wps": 4296.273801586775, "eta_in_seconds": 4316.924119954834, "at": "2024-05-25T22:42:26.561508"} +{"lr": 3.870269180138406e-05, "step": 218, "loss": 1.093568205833435, "percent_done": 43.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5548.996224077958, "avg_wps": 4300.727551831314, "eta_in_seconds": 4297.21524492535, "at": "2024-05-25T22:42:38.373204"} +{"lr": 3.851261907008817e-05, "step": 219, "loss": 1.4760338068008423, "percent_done": 43.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.141066551208496, "wps": 5534.63198190342, "avg_wps": 4305.110162880705, "eta_in_seconds": 4277.617831660188, "at": "2024-05-25T22:42:50.215507"} +{"lr": 3.8322173974506286e-05, "step": 220, "loss": 1.2785446643829346, "percent_done": 44.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13966703414917, "wps": 5540.802216305511, "avg_wps": 4309.478736584486, "eta_in_seconds": 4258.074148091403, "at": "2024-05-25T22:43:02.044583"} +{"lr": 3.813136484532385e-05, "step": 221, "loss": 1.3685591220855713, "percent_done": 44.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5533.759885374925, "avg_wps": 4313.797190617208, "eta_in_seconds": 4238.619293408156, "at": "2024-05-25T22:43:13.888729"} +{"lr": 3.794020002915029e-05, "step": 222, "loss": 1.6812156438827515, "percent_done": 44.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14044427871704, "wps": 5533.822049505497, "avg_wps": 4318.085456935062, "eta_in_seconds": 4219.232847913965, "at": "2024-05-25T22:43:25.732736"} +{"lr": 3.774868788815397e-05, "step": 223, "loss": 1.6355894804000854, "percent_done": 44.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13873529434204, "wps": 5535.39332722666, "avg_wps": 4322.3479806554005, "eta_in_seconds": 4199.909882602135, "at": "2024-05-25T22:43:37.573393"} +{"lr": 3.755683679969634e-05, "step": 224, "loss": 1.2441591024398804, "percent_done": 44.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5538.676162978722, "avg_wps": 4326.5897054741245, "eta_in_seconds": 4180.645088004215, "at": "2024-05-25T22:43:49.407047"} +{"lr": 3.736465515596552e-05, "step": 225, "loss": 1.7374337911605835, "percent_done": 45.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5527.72203358173, "avg_wps": 4330.772123855132, "eta_in_seconds": 4161.475017521117, "at": "2024-05-25T22:44:01.264121"} +{"lr": 3.717215136360919e-05, "step": 226, "loss": 1.3517248630523682, "percent_done": 45.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5533.533076126499, "avg_wps": 4334.941312950405, "eta_in_seconds": 4142.354579600613, "at": "2024-05-25T22:44:13.108762"} +{"lr": 3.697933384336687e-05, "step": 227, "loss": 1.5427135229110718, "percent_done": 45.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5532.932388814647, "avg_wps": 4339.080070889723, "eta_in_seconds": 4123.299802654115, "at": "2024-05-25T22:44:24.954749"} +{"lr": 3.6786211029701516e-05, "step": 228, "loss": 1.4166542291641235, "percent_done": 45.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 2669.9194216301294, "avg_wps": 4327.214910834508, "eta_in_seconds": 4119.460754160295, "at": "2024-05-25T22:44:49.501886"} +{"lr": 3.659279137043063e-05, "step": 229, "loss": 1.2034482955932617, "percent_done": 45.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1409330368042, "wps": 5547.563767731052, "avg_wps": 4331.375665085092, "eta_in_seconds": 4100.373039254975, "at": "2024-05-25T22:45:01.316589"} +{"lr": 3.639908332635672e-05, "step": 230, "loss": 1.5192251205444336, "percent_done": 46.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13909387588501, "wps": 5539.994608380083, "avg_wps": 4335.488016399378, "eta_in_seconds": 4081.367526116578, "at": "2024-05-25T22:45:13.147369"} +{"lr": 3.6205095370897137e-05, "step": 231, "loss": 1.5551331043243408, "percent_done": 46.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139253616333008, "wps": 5536.502116225615, "avg_wps": 4339.56319524393, "eta_in_seconds": 4062.4328317931204, "at": "2024-05-25T22:45:24.985583"} +{"lr": 3.601083598971351e-05, "step": 232, "loss": 1.3341258764266968, "percent_done": 46.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5530.741704186446, "avg_wps": 4343.595514073156, "eta_in_seconds": 4043.5735655159788, "at": "2024-05-25T22:45:36.836302"} +{"lr": 3.581631368034047e-05, "step": 233, "loss": 1.7266117334365845, "percent_done": 46.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5536.8398025431225, "avg_wps": 4347.616779511352, "eta_in_seconds": 4024.759514790236, "at": "2024-05-25T22:45:48.673797"} +{"lr": 3.5621536951813995e-05, "step": 234, "loss": 1.6123225688934326, "percent_done": 46.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5534.2751768553435, "avg_wps": 4351.604259377046, "eta_in_seconds": 4006.011337642996, "at": "2024-05-25T22:46:00.516802"} +{"lr": 3.542651432429918e-05, "step": 235, "loss": 1.3343654870986938, "percent_done": 47.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1411771774292, "wps": 5531.498640126004, "avg_wps": 4355.5577092161975, "eta_in_seconds": 3987.328640658805, "at": "2024-05-25T22:46:12.365791"} +{"lr": 3.523125432871754e-05, "step": 236, "loss": 1.1647117137908936, "percent_done": 47.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5534.28843643222, "avg_wps": 4359.492092862663, "eta_in_seconds": 3968.697185694161, "at": "2024-05-25T22:46:24.208726"} +{"lr": 3.503576550637384e-05, "step": 237, "loss": 1.777500867843628, "percent_done": 47.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5514.7734970101465, "avg_wps": 4363.348933563799, "eta_in_seconds": 3950.169528597015, "at": "2024-05-25T22:46:36.093776"} +{"lr": 3.484005640858246e-05, "step": 238, "loss": 1.4067996740341187, "percent_done": 47.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5525.385083236194, "avg_wps": 4367.208015584494, "eta_in_seconds": 3931.672578619308, "at": "2024-05-25T22:46:47.955734"} +{"lr": 3.464413559629336e-05, "step": 239, "loss": 1.2412711381912231, "percent_done": 47.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5534.256903256877, "avg_wps": 4371.064744126738, "eta_in_seconds": 3913.210396387587, "at": "2024-05-25T22:46:59.798816"} +{"lr": 3.444801163971754e-05, "step": 240, "loss": 1.4133297204971313, "percent_done": 48.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5530.940016732186, "avg_wps": 4374.887424455268, "eta_in_seconds": 3894.811076680819, "at": "2024-05-25T22:47:11.648940"} +{"lr": 3.4251693117952235e-05, "step": 241, "loss": 1.4693609476089478, "percent_done": 48.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1392240524292, "wps": 5522.709330349719, "avg_wps": 4378.663553752841, "eta_in_seconds": 3876.485094510668, "at": "2024-05-25T22:47:23.516714"} +{"lr": 3.4055188618605555e-05, "step": 242, "loss": 1.3353869915008545, "percent_done": 48.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.138741493225098, "wps": 5539.252870733412, "avg_wps": 4382.457837082424, "eta_in_seconds": 3858.1747112155945, "at": "2024-05-25T22:47:35.349209"} +{"lr": 3.3858506737420905e-05, "step": 243, "loss": 1.2679318189620972, "percent_done": 48.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13873529434204, "wps": 5519.522415991749, "avg_wps": 4386.1762998708455, "eta_in_seconds": 3839.9623837500444, "at": "2024-05-25T22:47:47.223794"} +{"lr": 3.366165607790091e-05, "step": 244, "loss": 1.3092782497406006, "percent_done": 48.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5533.8629359943325, "avg_wps": 4389.907602546346, "eta_in_seconds": 3821.7697316154104, "at": "2024-05-25T22:47:59.067713"} +{"lr": 3.3464645250931154e-05, "step": 245, "loss": 1.3463435173034668, "percent_done": 49.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5542.63763010593, "avg_wps": 4393.637262477201, "eta_in_seconds": 3803.6094018780454, "at": "2024-05-25T22:48:10.892919"} +{"lr": 3.3267482874403404e-05, "step": 246, "loss": 1.691806674003601, "percent_done": 49.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5529.3287773420025, "avg_wps": 4397.308731074106, "eta_in_seconds": 3785.529972541623, "at": "2024-05-25T22:48:22.746613"} +{"lr": 3.3070177572838744e-05, "step": 247, "loss": 1.520065426826477, "percent_done": 49.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5521.833222090956, "avg_wps": 4400.937287322642, "eta_in_seconds": 3767.5174440140668, "at": "2024-05-25T22:48:34.616243"} +{"lr": 3.287273797701024e-05, "step": 248, "loss": 1.6431244611740112, "percent_done": 49.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.140637397766113, "wps": 5534.171553779217, "avg_wps": 4404.574086490185, "eta_in_seconds": 3749.5275764926787, "at": "2024-05-25T22:48:46.459472"} +{"lr": 3.267517272356543e-05, "step": 249, "loss": 1.0544090270996094, "percent_done": 49.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5529.259818292591, "avg_wps": 4408.175091096154, "eta_in_seconds": 3731.597692937736, "at": "2024-05-25T22:48:58.313206"} +{"lr": 3.247749045464852e-05, "step": 250, "loss": 1.5963233709335327, "percent_done": 50.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5534.015569369136, "avg_wps": 4411.765210272437, "eta_in_seconds": 3713.706242084503, "at": "2024-05-25T22:49:10.156712"} +{"lr": 3.227969981752235e-05, "step": 251, "loss": 1.6758294105529785, "percent_done": 50.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5532.253890444075, "avg_wps": 4415.328036363264, "eta_in_seconds": 3695.8667318953935, "at": "2024-05-25T22:49:22.004135"} +{"lr": 3.208180946419016e-05, "step": 252, "loss": 1.1712573766708374, "percent_done": 50.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1399564743042, "wps": 5538.17723523053, "avg_wps": 4418.883257101735, "eta_in_seconds": 3678.0623189986695, "at": "2024-05-25T22:49:33.838737"} +{"lr": 3.188382805101706e-05, "step": 253, "loss": 1.2246155738830566, "percent_done": 50.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5540.9633863865265, "avg_wps": 4422.423054089256, "eta_in_seconds": 3660.2992979226847, "at": "2024-05-25T22:49:45.667391"} +{"lr": 3.168576423835144e-05, "step": 254, "loss": 1.5317556858062744, "percent_done": 50.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139402866363525, "wps": 5532.742953765316, "avg_wps": 4425.9199077964195, "eta_in_seconds": 3642.600032504149, "at": "2024-05-25T22:49:57.513821"} +{"lr": 3.148762669014611e-05, "step": 255, "loss": 1.5544838905334473, "percent_done": 51.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.141308784484863, "wps": 5527.811964316946, "avg_wps": 4429.382399854723, "eta_in_seconds": 3624.956833830067, "at": "2024-05-25T22:50:09.370538"} +{"lr": 3.12894240735793e-05, "step": 256, "loss": 1.4938002824783325, "percent_done": 51.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5518.587156727684, "avg_wps": 4432.799988547965, "eta_in_seconds": 3607.377738971263, "at": "2024-05-25T22:50:21.247309"} +{"lr": 3.109116505867555e-05, "step": 257, "loss": 1.6491687297821045, "percent_done": 51.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5539.9196887721655, "avg_wps": 4436.249630038278, "eta_in_seconds": 3589.7997921867595, "at": "2024-05-25T22:50:33.078155"} +{"lr": 3.089285831792642e-05, "step": 258, "loss": 1.2178406715393066, "percent_done": 51.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14020013809204, "wps": 5522.017029790733, "avg_wps": 4439.633132010343, "eta_in_seconds": 3572.302379142406, "at": "2024-05-25T22:50:44.947419"} +{"lr": 3.0694512525911205e-05, "step": 259, "loss": 1.3444440364837646, "percent_done": 51.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1399564743042, "wps": 5536.3724279705675, "avg_wps": 4443.031400791835, "eta_in_seconds": 3554.8198010000942, "at": "2024-05-25T22:50:56.785908"} +{"lr": 3.0496136358917387e-05, "step": 260, "loss": 1.1937881708145142, "percent_done": 52.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5539.539762552092, "avg_wps": 4446.416528515833, "eta_in_seconds": 3537.3744000654956, "at": "2024-05-25T22:51:08.617601"} +{"lr": 3.029773849456115e-05, "step": 261, "loss": 1.566652536392212, "percent_done": 52.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5530.235860158809, "avg_wps": 4449.757779523455, "eta_in_seconds": 3519.990250273226, "at": "2024-05-25T22:51:20.469390"} +{"lr": 3.009932761140782e-05, "step": 262, "loss": 1.2333173751831055, "percent_done": 52.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13897943496704, "wps": 5520.503892488975, "avg_wps": 4453.054366147088, "eta_in_seconds": 3502.6673194415694, "at": "2024-05-25T22:51:32.341856"} +{"lr": 2.9900912388592177e-05, "step": 263, "loss": 1.7521350383758545, "percent_done": 52.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5531.126768482994, "avg_wps": 4456.356985652556, "eta_in_seconds": 3485.365299504973, "at": "2024-05-25T22:51:44.191626"} +{"lr": 2.9702501505438846e-05, "step": 264, "loss": 1.538033366203308, "percent_done": 52.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13849115371704, "wps": 5525.8686004459205, "avg_wps": 4459.626471859686, "eta_in_seconds": 3468.1146722923627, "at": "2024-05-25T22:51:56.052683"} +{"lr": 2.9504103641082615e-05, "step": 265, "loss": 1.256603717803955, "percent_done": 53.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5532.640501648141, "avg_wps": 4462.89267745163, "eta_in_seconds": 3450.891857160712, "at": "2024-05-25T22:52:07.899351"} +{"lr": 2.93057274740888e-05, "step": 266, "loss": 1.1758630275726318, "percent_done": 53.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5506.620163418131, "avg_wps": 4466.075015979773, "eta_in_seconds": 3433.75871321671, "at": "2024-05-25T22:52:19.801851"} +{"lr": 2.9107381682073582e-05, "step": 267, "loss": 1.818198800086975, "percent_done": 53.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5527.10704803808, "avg_wps": 4469.288363781493, "eta_in_seconds": 3416.6262628621375, "at": "2024-05-25T22:52:31.660121"} +{"lr": 2.8909074941324465e-05, "step": 268, "loss": 1.5012140274047852, "percent_done": 53.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5508.707763393108, "avg_wps": 4472.437203406224, "eta_in_seconds": 3399.567463668425, "at": "2024-05-25T22:52:43.558114"} +{"lr": 2.8710815926420708e-05, "step": 269, "loss": 1.3686946630477905, "percent_done": 53.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5518.555802222994, "avg_wps": 4475.591144741124, "eta_in_seconds": 3382.528812487329, "at": "2024-05-25T22:52:55.434835"} +{"lr": 2.851261330985389e-05, "step": 270, "loss": 1.3505845069885254, "percent_done": 54.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1414213180542, "wps": 5519.38221771944, "avg_wps": 4478.728141323957, "eta_in_seconds": 3365.5268916465616, "at": "2024-05-25T22:53:07.309876"} +{"lr": 2.8314475761648556e-05, "step": 271, "loss": 1.2980961799621582, "percent_done": 54.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13862705230713, "wps": 5517.019203439364, "avg_wps": 4481.840586670939, "eta_in_seconds": 3348.567114286317, "at": "2024-05-25T22:53:19.189873"} +{"lr": 2.811641194898294e-05, "step": 272, "loss": 1.1465059518814087, "percent_done": 54.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139700889587402, "wps": 5535.403025114344, "avg_wps": 4484.9789450574035, "eta_in_seconds": 3331.6116269546396, "at": "2024-05-25T22:53:31.030440"} +{"lr": 2.7918430535809843e-05, "step": 273, "loss": 1.430358648300171, "percent_done": 54.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5534.783320362093, "avg_wps": 4488.097169410093, "eta_in_seconds": 3314.6947221633714, "at": "2024-05-25T22:53:42.872491"} +{"lr": 2.772054018247765e-05, "step": 274, "loss": 1.3976505994796753, "percent_done": 54.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5531.3996846627415, "avg_wps": 4491.188788370687, "eta_in_seconds": 3297.820843860181, "at": "2024-05-25T22:53:54.746479"} +{"lr": 2.7522749545351488e-05, "step": 275, "loss": 1.4968034029006958, "percent_done": 55.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5516.209767995939, "avg_wps": 4494.2255741311355, "eta_in_seconds": 3281.010211164301, "at": "2024-05-25T22:54:06.628320"} +{"lr": 2.7325067276434586e-05, "step": 276, "loss": 1.3039748668670654, "percent_done": 55.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5521.563467348104, "avg_wps": 4497.257299739244, "eta_in_seconds": 3264.225954083429, "at": "2024-05-25T22:54:18.498509"} +{"lr": 2.7127502022989765e-05, "step": 277, "loss": 1.4881929159164429, "percent_done": 55.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5527.085932222587, "avg_wps": 4500.284414865999, "eta_in_seconds": 3247.4676382059656, "at": "2024-05-25T22:54:30.356878"} +{"lr": 2.693006242716126e-05, "step": 278, "loss": 1.4972293376922607, "percent_done": 55.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5530.62141040813, "avg_wps": 4503.302223255821, "eta_in_seconds": 3230.738528910301, "at": "2024-05-25T22:54:42.207725"} +{"lr": 2.6732757125596597e-05, "step": 279, "loss": 1.898256540298462, "percent_done": 55.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5531.435526390087, "avg_wps": 4506.304342153716, "eta_in_seconds": 3214.043016250843, "at": "2024-05-25T22:54:54.056755"} +{"lr": 2.653559474906885e-05, "step": 280, "loss": 1.4742891788482666, "percent_done": 56.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139620780944824, "wps": 5527.689352432536, "avg_wps": 4509.280082486838, "eta_in_seconds": 3197.388438122613, "at": "2024-05-25T22:55:05.913967"} +{"lr": 2.6338583922099093e-05, "step": 281, "loss": 1.401398777961731, "percent_done": 56.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13962173461914, "wps": 5526.032346794623, "avg_wps": 4512.2346034606035, "eta_in_seconds": 3180.7707846113794, "at": "2024-05-25T22:55:17.774548"} +{"lr": 2.6141733262579107e-05, "step": 282, "loss": 1.512309193611145, "percent_done": 56.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13897943496704, "wps": 5514.92718144086, "avg_wps": 4515.145660230392, "eta_in_seconds": 3164.2053380113966, "at": "2024-05-25T22:55:29.659065"} +{"lr": 2.5945051381394456e-05, "step": 283, "loss": 1.4032942056655884, "percent_done": 56.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5526.4626437996, "avg_wps": 4518.06716304446, "eta_in_seconds": 3147.6539605969674, "at": "2024-05-25T22:55:41.518790"} +{"lr": 2.574854688204777e-05, "step": 284, "loss": 1.499544620513916, "percent_done": 56.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1411771774292, "wps": 5533.669315404924, "avg_wps": 4520.988794962859, "eta_in_seconds": 3131.1238850606996, "at": "2024-05-25T22:55:53.363059"} +{"lr": 2.555222836028246e-05, "step": 285, "loss": 1.3525288105010986, "percent_done": 57.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5532.152347152449, "avg_wps": 4523.890107148779, "eta_in_seconds": 3114.629150194034, "at": "2024-05-25T22:56:05.210709"} +{"lr": 2.5356104403706647e-05, "step": 286, "loss": 1.1315374374389648, "percent_done": 57.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5544.867167346487, "avg_wps": 4526.804516454784, "eta_in_seconds": 3098.146595246308, "at": "2024-05-25T22:56:17.030982"} +{"lr": 2.5160183591417547e-05, "step": 287, "loss": 1.4872703552246094, "percent_done": 57.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14044427871704, "wps": 5532.0106158739645, "avg_wps": 4529.672370232537, "eta_in_seconds": 3081.7169232227243, "at": "2024-05-25T22:56:28.878790"} +{"lr": 2.4964474493626167e-05, "step": 288, "loss": 1.560407042503357, "percent_done": 57.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5526.816219656265, "avg_wps": 4532.51178767463, "eta_in_seconds": 3065.32727345162, "at": "2024-05-25T22:56:40.737731"} +{"lr": 2.4768985671282466e-05, "step": 289, "loss": 1.445494532585144, "percent_done": 57.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5533.251372845789, "avg_wps": 4535.350057298082, "eta_in_seconds": 3048.958917239133, "at": "2024-05-25T22:56:52.583051"} +{"lr": 2.457372567570083e-05, "step": 290, "loss": 1.3846065998077393, "percent_done": 58.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5537.491649158071, "avg_wps": 4538.18210082149, "eta_in_seconds": 3032.615195742969, "at": "2024-05-25T22:57:04.419083"} +{"lr": 2.4378703048186006e-05, "step": 291, "loss": 1.8785253763198853, "percent_done": 58.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5532.5514159347595, "avg_wps": 4540.986756178741, "eta_in_seconds": 3016.3100522949117, "at": "2024-05-25T22:57:16.265721"} +{"lr": 2.4183926319659536e-05, "step": 292, "loss": 1.461996078491211, "percent_done": 58.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14020013809204, "wps": 5512.864386334081, "avg_wps": 4543.7299970438635, "eta_in_seconds": 3000.065586834738, "at": "2024-05-25T22:57:28.154768"} +{"lr": 2.3989404010286496e-05, "step": 293, "loss": 1.5814299583435059, "percent_done": 58.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5528.897033042693, "avg_wps": 4546.494903598449, "eta_in_seconds": 2983.826505394926, "at": "2024-05-25T22:57:40.009228"} +{"lr": 2.379514462910286e-05, "step": 294, "loss": 1.5236884355545044, "percent_done": 58.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5527.577194556655, "avg_wps": 4549.241293935507, "eta_in_seconds": 2967.6192419155927, "at": "2024-05-25T22:57:51.866663"} +{"lr": 2.3601156673643287e-05, "step": 295, "loss": 1.4485158920288086, "percent_done": 59.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5532.5411712616515, "avg_wps": 4551.983752141016, "eta_in_seconds": 2951.434084904396, "at": "2024-05-25T22:58:03.713288"} +{"lr": 2.340744862956937e-05, "step": 296, "loss": 1.3660223484039307, "percent_done": 59.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5534.305038849152, "avg_wps": 4554.714992730175, "eta_in_seconds": 2935.275647617675, "at": "2024-05-25T22:58:15.556179"} +{"lr": 2.3214028970298496e-05, "step": 297, "loss": 1.129741907119751, "percent_done": 59.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.140511512756348, "wps": 5518.5887078431715, "avg_wps": 4557.395101013946, "eta_in_seconds": 2919.169329216183, "at": "2024-05-25T22:58:27.432813"} +{"lr": 2.3020906156633134e-05, "step": 298, "loss": 1.5862302780151367, "percent_done": 59.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14044427871704, "wps": 5533.277436713865, "avg_wps": 4560.093912398799, "eta_in_seconds": 2903.07003634408, "at": "2024-05-25T22:58:39.277966"} +{"lr": 2.2828088636390805e-05, "step": 299, "loss": 1.3507128953933716, "percent_done": 59.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1414213180542, "wps": 5517.752007677699, "avg_wps": 4562.742431270372, "eta_in_seconds": 2887.02161001282, "at": "2024-05-25T22:58:51.156507"} +{"lr": 2.2635584844034485e-05, "step": 300, "loss": 1.279242753982544, "percent_done": 60.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5522.372588765262, "avg_wps": 4565.386876121166, "eta_in_seconds": 2870.9943660100303, "at": "2024-05-25T22:59:03.024962"} +{"lr": 2.244340320030367e-05, "step": 301, "loss": 1.6162009239196777, "percent_done": 60.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5596.0634045652, "avg_wps": 4568.182100476005, "eta_in_seconds": 2854.891445470411, "at": "2024-05-25T22:59:29.055705"} +{"lr": 2.225155211184604e-05, "step": 302, "loss": 1.3532904386520386, "percent_done": 60.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5549.411170931847, "avg_wps": 4570.8582742782555, "eta_in_seconds": 2838.8821576510045, "at": "2024-05-25T22:59:40.866360"} +{"lr": 2.2060039970849715e-05, "step": 303, "loss": 1.305881142616272, "percent_done": 60.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5544.700065993084, "avg_wps": 4573.509320437121, "eta_in_seconds": 2822.907114741826, "at": "2024-05-25T22:59:52.687165"} +{"lr": 2.186887515467616e-05, "step": 304, "loss": 1.4735749959945679, "percent_done": 60.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139169692993164, "wps": 5538.719688114189, "avg_wps": 4576.132557891767, "eta_in_seconds": 2806.9676386117935, "at": "2024-05-25T23:00:04.520603"} +{"lr": 2.167806602549372e-05, "step": 305, "loss": 1.7670332193374634, "percent_done": 61.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139360904693604, "wps": 5532.913010383309, "avg_wps": 4578.728550846804, "eta_in_seconds": 2791.063033784022, "at": "2024-05-25T23:00:16.366505"} +{"lr": 2.148762092991183e-05, "step": 306, "loss": 1.459661841392517, "percent_done": 61.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13961887359619, "wps": 5536.567799009618, "avg_wps": 4581.318677984091, "eta_in_seconds": 2775.1800068172756, "at": "2024-05-25T23:00:28.204548"} +{"lr": 2.129754819861595e-05, "step": 307, "loss": 1.5853192806243896, "percent_done": 61.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5528.797503413538, "avg_wps": 4583.877460962019, "eta_in_seconds": 2759.3337971441906, "at": "2024-05-25T23:00:40.059221"} +{"lr": 2.1107856146003084e-05, "step": 308, "loss": 1.692198634147644, "percent_done": 61.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5531.496302554545, "avg_wps": 4586.428487465176, "eta_in_seconds": 2743.5099085027523, "at": "2024-05-25T23:00:51.908251"} +{"lr": 2.0918553069818132e-05, "step": 309, "loss": 1.3194557428359985, "percent_done": 61.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5528.914381590603, "avg_wps": 4588.96006243418, "eta_in_seconds": 2727.7151750499766, "at": "2024-05-25T23:01:03.762668"} +{"lr": 2.0729647250790905e-05, "step": 310, "loss": 1.5714393854141235, "percent_done": 62.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13873529434204, "wps": 5520.829983091125, "avg_wps": 4591.460062602073, "eta_in_seconds": 2711.9565084365104, "at": "2024-05-25T23:01:15.634504"} +{"lr": 2.0541146952273892e-05, "step": 311, "loss": 1.3738967180252075, "percent_done": 62.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139092445373535, "wps": 5538.4990562134735, "avg_wps": 4593.9858979910505, "eta_in_seconds": 2696.199830612569, "at": "2024-05-25T23:01:27.468432"} +{"lr": 2.0353060419880816e-05, "step": 312, "loss": 1.5305222272872925, "percent_done": 62.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5536.386701186902, "avg_wps": 4596.493631016975, "eta_in_seconds": 2680.471026188288, "at": "2024-05-25T23:01:39.306881"} +{"lr": 2.01653958811259e-05, "step": 313, "loss": 1.6897908449172974, "percent_done": 62.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13897943496704, "wps": 5529.008132358318, "avg_wps": 4598.971764930777, "eta_in_seconds": 2664.7765253641355, "at": "2024-05-25T23:01:51.161305"} +{"lr": 1.997816154506404e-05, "step": 314, "loss": 1.4919114112854004, "percent_done": 62.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5529.193085366338, "avg_wps": 4601.43717054892, "eta_in_seconds": 2649.1062570666054, "at": "2024-05-25T23:02:03.015069"} +{"lr": 1.979136560193164e-05, "step": 315, "loss": 1.362998127937317, "percent_done": 63.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5534.578825955238, "avg_wps": 4603.901384762293, "eta_in_seconds": 2633.4534532229104, "at": "2024-05-25T23:02:14.857367"} +{"lr": 1.9605016222788395e-05, "step": 316, "loss": 1.5362869501113892, "percent_done": 63.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5525.791396409157, "avg_wps": 4606.333325022306, "eta_in_seconds": 2617.8357381337805, "at": "2024-05-25T23:02:26.718549"} +{"lr": 1.9419121559159824e-05, "step": 317, "loss": 0.9179596900939941, "percent_done": 63.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5531.0191454039505, "avg_wps": 4608.763929184131, "eta_in_seconds": 2602.235259666052, "at": "2024-05-25T23:02:38.568435"} +{"lr": 1.9233689742680746e-05, "step": 318, "loss": 1.6024270057678223, "percent_done": 63.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13916778564453, "wps": 5538.60161382314, "avg_wps": 4611.198339043205, "eta_in_seconds": 2586.6490927117425, "at": "2024-05-25T23:02:50.402344"} +{"lr": 1.9048728884739516e-05, "step": 319, "loss": 1.501809000968933, "percent_done": 63.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5530.255776156526, "avg_wps": 4613.601854202438, "eta_in_seconds": 2571.09659109295, "at": "2024-05-25T23:03:02.253864"} +{"lr": 1.886424707612324e-05, "step": 320, "loss": 1.1742545366287231, "percent_done": 64.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5541.663239100619, "avg_wps": 4616.017615678441, "eta_in_seconds": 2555.5535056740046, "at": "2024-05-25T23:03:14.081117"} +{"lr": 1.86802523866639e-05, "step": 321, "loss": 1.3116861581802368, "percent_done": 64.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139100551605225, "wps": 5535.098393909138, "avg_wps": 4618.4066119485515, "eta_in_seconds": 2540.0414007831587, "at": "2024-05-25T23:03:25.922345"} +{"lr": 1.8496752864885245e-05, "step": 322, "loss": 1.5555421113967896, "percent_done": 64.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5531.708918326537, "avg_wps": 4620.7758803812885, "eta_in_seconds": 2524.556113947993, "at": "2024-05-25T23:03:37.771006"} +{"lr": 1.831375653765083e-05, "step": 323, "loss": 1.3761317729949951, "percent_done": 64.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5539.595246617048, "avg_wps": 4623.149917805754, "eta_in_seconds": 2509.084110667462, "at": "2024-05-25T23:03:49.602566"} +{"lr": 1.813127140981282e-05, "step": 324, "loss": 1.3383431434631348, "percent_done": 64.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5531.276023138408, "avg_wps": 4625.493789967782, "eta_in_seconds": 2493.644251564403, "at": "2024-05-25T23:04:01.451921"} +{"lr": 1.794930546386188e-05, "step": 325, "loss": 1.469743013381958, "percent_done": 65.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.140552043914795, "wps": 5536.761287914303, "avg_wps": 4627.837397100857, "eta_in_seconds": 2478.2201741108524, "at": "2024-05-25T23:04:13.289520"} +{"lr": 1.7767866659577976e-05, "step": 326, "loss": 1.0628798007965088, "percent_done": 65.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.138704299926758, "wps": 5531.573888719816, "avg_wps": 4630.157842197907, "eta_in_seconds": 2462.8240307649953, "at": "2024-05-25T23:04:25.138260"} +{"lr": 1.758696293368218e-05, "step": 327, "loss": 1.1498101949691772, "percent_done": 65.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5545.600563860817, "avg_wps": 4632.496409804798, "eta_in_seconds": 2447.4337370242547, "at": "2024-05-25T23:04:36.957089"} +{"lr": 1.740660219948953e-05, "step": 328, "loss": 1.3323389291763306, "percent_done": 65.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5542.183691117202, "avg_wps": 4634.815778759825, "eta_in_seconds": 2432.0690482796695, "at": "2024-05-25T23:04:48.783043"} +{"lr": 1.7226792346562806e-05, "step": 329, "loss": 0.9280859231948853, "percent_done": 65.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1399564743042, "wps": 5529.7981894762115, "avg_wps": 4637.096937432788, "eta_in_seconds": 2416.739643619416, "at": "2024-05-25T23:05:00.635547"} +{"lr": 1.7047541240367497e-05, "step": 330, "loss": 1.5664188861846924, "percent_done": 66.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5541.807699985924, "avg_wps": 4639.392057656485, "eta_in_seconds": 2401.4180870128403, "at": "2024-05-25T23:05:12.462379"} +{"lr": 1.6868856721927658e-05, "step": 331, "loss": 1.3574612140655518, "percent_done": 66.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5522.906179539739, "avg_wps": 4641.6353654054765, "eta_in_seconds": 2386.1383172291644, "at": "2024-05-25T23:05:24.329689"} +{"lr": 1.669074660748301e-05, "step": 332, "loss": 1.5006729364395142, "percent_done": 66.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.140617847442627, "wps": 5521.832556545177, "avg_wps": 4643.865023388572, "eta_in_seconds": 2370.880278506911, "at": "2024-05-25T23:05:36.199372"} +{"lr": 1.6513218688146936e-05, "step": 333, "loss": 1.2552119493484497, "percent_done": 66.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5535.35431307931, "avg_wps": 4646.112091076746, "eta_in_seconds": 2355.6280574934617, "at": "2024-05-25T23:05:48.039929"} +{"lr": 1.6336280729565724e-05, "step": 334, "loss": 1.4726775884628296, "percent_done": 66.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5531.309525849591, "avg_wps": 4648.33931324541, "eta_in_seconds": 2340.4005746741495, "at": "2024-05-25T23:05:59.889218"} +{"lr": 1.6159940471578926e-05, "step": 335, "loss": 1.24460768699646, "percent_done": 67.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.138813495635986, "wps": 5530.559095614715, "avg_wps": 4650.553772113003, "eta_in_seconds": 2325.1940585748475, "at": "2024-05-25T23:06:11.740111"} +{"lr": 1.598420562788065e-05, "step": 336, "loss": 1.1442080736160278, "percent_done": 67.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5534.7047526034785, "avg_wps": 4652.76586773327, "eta_in_seconds": 2310.003190690563, "at": "2024-05-25T23:06:23.582104"} +{"lr": 1.5809083885682293e-05, "step": 337, "loss": 1.2265191078186035, "percent_done": 67.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5528.203625111734, "avg_wps": 4654.953259967956, "eta_in_seconds": 2294.838938957152, "at": "2024-05-25T23:06:35.438183"} +{"lr": 1.5634582905376138e-05, "step": 338, "loss": 1.097861409187317, "percent_done": 67.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.138688564300537, "wps": 5533.373674661561, "avg_wps": 4657.140593795531, "eta_in_seconds": 2279.688960677773, "at": "2024-05-25T23:06:47.283064"} +{"lr": 1.546071032020041e-05, "step": 339, "loss": 1.5978518724441528, "percent_done": 67.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14020013809204, "wps": 5522.545004202414, "avg_wps": 4659.294368598296, "eta_in_seconds": 2264.5695174598413, "at": "2024-05-25T23:06:59.151214"} +{"lr": 1.5287473735905225e-05, "step": 340, "loss": 1.364516258239746, "percent_done": 68.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5530.858108143184, "avg_wps": 4661.454843378572, "eta_in_seconds": 2249.460812624763, "at": "2024-05-25T23:07:11.001606"} +{"lr": 1.5114880730419973e-05, "step": 341, "loss": 1.7650222778320312, "percent_done": 68.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.140679836273193, "wps": 5537.121648253804, "avg_wps": 4663.6176783473375, "eta_in_seconds": 2234.364975581071, "at": "2024-05-25T23:07:22.838743"} +{"lr": 1.4942938853521888e-05, "step": 342, "loss": 1.610933542251587, "percent_done": 68.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139131546020508, "wps": 5538.157038975037, "avg_wps": 4665.772004735956, "eta_in_seconds": 2219.2871810901934, "at": "2024-05-25T23:07:34.673395"} +{"lr": 1.4771655626505637e-05, "step": 343, "loss": 1.2632454633712769, "percent_done": 68.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5533.930338745834, "avg_wps": 4667.906982341584, "eta_in_seconds": 2204.2324405613167, "at": "2024-05-25T23:07:46.517174"} +{"lr": 1.4601038541854481e-05, "step": 344, "loss": 1.2216689586639404, "percent_done": 68.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5536.899136097767, "avg_wps": 4670.037627758494, "eta_in_seconds": 2189.1934958363686, "at": "2024-05-25T23:07:58.354608"} +{"lr": 1.4431095062912406e-05, "step": 345, "loss": 1.3331900835037231, "percent_done": 69.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5540.763237562274, "avg_wps": 4672.165820111177, "eta_in_seconds": 2174.1694090297256, "at": "2024-05-25T23:08:10.183720"} +{"lr": 1.426183262355772e-05, "step": 346, "loss": 1.6556040048599243, "percent_done": 69.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13903045654297, "wps": 5530.2705741695045, "avg_wps": 4674.2620112551, "eta_in_seconds": 2159.173785230328, "at": "2024-05-25T23:08:22.035434"} +{"lr": 1.4093258627877864e-05, "step": 347, "loss": 1.0908232927322388, "percent_done": 69.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5531.034949151135, "avg_wps": 4676.349560986865, "eta_in_seconds": 2144.1955673399166, "at": "2024-05-25T23:08:33.885303"} +{"lr": 1.392538044984549e-05, "step": 348, "loss": 1.2147232294082642, "percent_done": 69.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1409330368042, "wps": 2773.92066582999, "avg_wps": 4667.151695151093, "eta_in_seconds": 2134.37930683706, "at": "2024-05-25T23:08:57.512262"} +{"lr": 1.3758205432995999e-05, "step": 349, "loss": 1.4657495021820068, "percent_done": 69.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5554.656676722703, "avg_wps": 4669.289356670141, "eta_in_seconds": 2119.3666196470617, "at": "2024-05-25T23:09:09.311908"} +{"lr": 1.3591740890106174e-05, "step": 350, "loss": 1.326554298400879, "percent_done": 70.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5523.354524317463, "avg_wps": 4671.353133559756, "eta_in_seconds": 2104.400955983571, "at": "2024-05-25T23:09:21.178377"} +{"lr": 1.342599410287438e-05, "step": 351, "loss": 1.2489190101623535, "percent_done": 70.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5540.562209772346, "avg_wps": 4673.441949404009, "eta_in_seconds": 2089.437315305753, "at": "2024-05-25T23:09:33.007968"} +{"lr": 1.3260972321602061e-05, "step": 352, "loss": 1.0407387018203735, "percent_done": 70.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.141040325164795, "wps": 5523.735119611841, "avg_wps": 4675.486604219299, "eta_in_seconds": 2074.5066387843003, "at": "2024-05-25T23:09:44.873582"} +{"lr": 1.3096682764876501e-05, "step": 353, "loss": 1.242996096611023, "percent_done": 70.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5532.060271096363, "avg_wps": 4677.538335435427, "eta_in_seconds": 2059.5858994928362, "at": "2024-05-25T23:09:56.721371"} +{"lr": 1.2933132619255162e-05, "step": 354, "loss": 1.3015520572662354, "percent_done": 70.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5528.803730860661, "avg_wps": 4679.573674806064, "eta_in_seconds": 2044.6854061757106, "at": "2024-05-25T23:10:08.576109"} +{"lr": 1.2770329038951215e-05, "step": 355, "loss": 1.1245949268341064, "percent_done": 71.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5540.074889612845, "avg_wps": 4681.622023299127, "eta_in_seconds": 2029.792228571126, "at": "2024-05-25T23:10:20.406772"} +{"lr": 1.2608279145520686e-05, "step": 356, "loss": 1.2131990194320679, "percent_done": 71.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5537.3947101643935, "avg_wps": 4683.655259638721, "eta_in_seconds": 2014.918578940831, "at": "2024-05-25T23:10:32.243198"} +{"lr": 1.2446990027550896e-05, "step": 357, "loss": 1.1643948554992676, "percent_done": 71.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5543.629134033885, "avg_wps": 4685.691347669286, "eta_in_seconds": 2000.0566201744293, "at": "2024-05-25T23:10:44.066282"} +{"lr": 1.2286468740350344e-05, "step": 358, "loss": 1.3531920909881592, "percent_done": 71.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14020013809204, "wps": 5526.955684548774, "avg_wps": 4687.684414382027, "eta_in_seconds": 1985.225791106677, "at": "2024-05-25T23:10:55.925040"} +{"lr": 1.2126722305640172e-05, "step": 359, "loss": 1.5578019618988037, "percent_done": 71.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5545.045912070976, "avg_wps": 4689.704221201127, "eta_in_seconds": 1970.3963329340422, "at": "2024-05-25T23:11:07.745087"} +{"lr": 1.1967757711246922e-05, "step": 360, "loss": 1.34718918800354, "percent_done": 72.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5539.455143120374, "avg_wps": 4691.703404629848, "eta_in_seconds": 1955.5882392194535, "at": "2024-05-25T23:11:19.577055"} +{"lr": 1.1809581910796943e-05, "step": 361, "loss": 1.3180506229400635, "percent_done": 72.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139734745025635, "wps": 5527.031031857379, "avg_wps": 4693.668438987415, "eta_in_seconds": 1940.8068802502016, "at": "2024-05-25T23:11:31.435613"} +{"lr": 1.1652201823412147e-05, "step": 362, "loss": 1.455444574356079, "percent_done": 72.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13906764984131, "wps": 5529.942922418844, "avg_wps": 4695.630052750505, "eta_in_seconds": 1926.0392957708455, "at": "2024-05-25T23:11:43.287896"} +{"lr": 1.1495624333407409e-05, "step": 363, "loss": 1.326683759689331, "percent_done": 72.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5538.070788116307, "avg_wps": 4697.598619463122, "eta_in_seconds": 1911.2812156407958, "at": "2024-05-25T23:11:55.122857"} +{"lr": 1.133985628998939e-05, "step": 364, "loss": 1.1185904741287231, "percent_done": 72.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13995599746704, "wps": 5531.728622291043, "avg_wps": 4699.545446399584, "eta_in_seconds": 1896.5442725590297, "at": "2024-05-25T23:12:06.971428"} +{"lr": 1.1184904506956906e-05, "step": 365, "loss": 1.4800939559936523, "percent_done": 73.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5534.16809974351, "avg_wps": 4701.488032567433, "eta_in_seconds": 1881.8212316428146, "at": "2024-05-25T23:12:18.814623"} +{"lr": 1.1030775762402946e-05, "step": 366, "loss": 1.575332522392273, "percent_done": 73.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139241695404053, "wps": 5538.445602773564, "avg_wps": 4703.4300322287345, "eta_in_seconds": 1867.110585216616, "at": "2024-05-25T23:12:30.648620"} +{"lr": 1.0877476798418077e-05, "step": 367, "loss": 1.0277793407440186, "percent_done": 73.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14020013809204, "wps": 5535.981169787024, "avg_wps": 4705.358191652899, "eta_in_seconds": 1852.4175301812977, "at": "2024-05-25T23:12:42.488063"} +{"lr": 1.0725014320795634e-05, "step": 368, "loss": 1.2328702211380005, "percent_done": 73.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5536.696492717369, "avg_wps": 4707.278845847564, "eta_in_seconds": 1837.7394421048787, "at": "2024-05-25T23:12:54.325961"} +{"lr": 1.0573394998738269e-05, "step": 369, "loss": 1.4363727569580078, "percent_done": 73.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5543.91592029221, "avg_wps": 4709.2047810923605, "eta_in_seconds": 1823.071282537972, "at": "2024-05-25T23:13:06.148393"} +{"lr": 1.0422625464566322e-05, "step": 370, "loss": 1.3193644285202026, "percent_done": 74.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5538.419267011386, "avg_wps": 4711.111131255367, "eta_in_seconds": 1808.4226337767936, "at": "2024-05-25T23:13:17.982601"} +{"lr": 1.0272712313427651e-05, "step": 371, "loss": 1.3883593082427979, "percent_done": 74.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5545.943724907959, "avg_wps": 4713.02340307365, "eta_in_seconds": 1793.7835815724015, "at": "2024-05-25T23:13:29.800728"} +{"lr": 1.0123662103009122e-05, "step": 372, "loss": 1.3066599369049072, "percent_done": 74.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5540.765806345092, "avg_wps": 4714.916864705352, "eta_in_seconds": 1779.1635018625568, "at": "2024-05-25T23:13:41.654050"} +{"lr": 9.97548135324981e-06, "step": 373, "loss": 1.5044260025024414, "percent_done": 74.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5537.0922020094395, "avg_wps": 4716.794541405861, "eta_in_seconds": 1764.561065133711, "at": "2024-05-25T23:13:53.491167"} +{"lr": 9.828176546055728e-06, "step": 374, "loss": 1.1372315883636475, "percent_done": 74.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5532.241976728904, "avg_wps": 4718.654234834191, "eta_in_seconds": 1749.9769190632724, "at": "2024-05-25T23:14:05.338589"} +{"lr": 9.681754125016368e-06, "step": 375, "loss": 1.3641146421432495, "percent_done": 75.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13897943496704, "wps": 5536.0754948569775, "avg_wps": 4720.512902938775, "eta_in_seconds": 1735.4046410719554, "at": "2024-05-25T23:14:17.177809"} +{"lr": 9.536220495122747e-06, "step": 376, "loss": 1.6401150226593018, "percent_done": 75.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14116334915161, "wps": 5530.04416210854, "avg_wps": 4722.351453104716, "eta_in_seconds": 1720.8511650815924, "at": "2024-05-25T23:14:29.029913"} +{"lr": 9.391582022487311e-06, "step": 377, "loss": 1.5790910720825195, "percent_done": 75.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1399564743042, "wps": 5525.936141861639, "avg_wps": 4724.17371292723, "eta_in_seconds": 1706.3149007290049, "at": "2024-05-25T23:14:40.890834"} +{"lr": 9.247845034065422e-06, "step": 378, "loss": 1.289422869682312, "percent_done": 75.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5535.396894261858, "avg_wps": 4726.006002270691, "eta_in_seconds": 1691.7862559121752, "at": "2024-05-25T23:14:52.731475"} +{"lr": 9.105015817378586e-06, "step": 379, "loss": 1.0527746677398682, "percent_done": 75.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1411771774292, "wps": 5541.28396736375, "avg_wps": 4727.841352638085, "eta_in_seconds": 1677.2677864021866, "at": "2024-05-25T23:15:04.559570"} +{"lr": 8.963100620239454e-06, "step": 380, "loss": 1.3100308179855347, "percent_done": 76.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1399564743042, "wps": 5539.69002981415, "avg_wps": 4729.665401399196, "eta_in_seconds": 1662.7645578635365, "at": "2024-05-25T23:15:16.391059"} +{"lr": 8.82210565047849e-06, "step": 381, "loss": 0.956969141960144, "percent_done": 76.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5503.388318396743, "avg_wps": 4731.41130809534, "eta_in_seconds": 1648.2997338778077, "at": "2024-05-25T23:15:28.300572"} +{"lr": 8.682037075672413e-06, "step": 382, "loss": 1.262111783027649, "percent_done": 76.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139315605163574, "wps": 5537.823543105449, "avg_wps": 4733.2156171182, "eta_in_seconds": 1633.8254213545335, "at": "2024-05-25T23:15:40.136043"} +{"lr": 8.542901022874465e-06, "step": 383, "loss": 1.507392406463623, "percent_done": 76.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13897943496704, "wps": 5533.710422440849, "avg_wps": 4735.004013022269, "eta_in_seconds": 1619.367582141886, "at": "2024-05-25T23:15:51.980308"} +{"lr": 8.404703578346311e-06, "step": 384, "loss": 1.2510004043579102, "percent_done": 76.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13886070251465, "wps": 5541.021244600094, "avg_wps": 4736.7983672624005, "eta_in_seconds": 1604.918641363581, "at": "2024-05-25T23:16:03.808950"} +{"lr": 8.267450787291907e-06, "step": 385, "loss": 1.2303383350372314, "percent_done": 77.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13960361480713, "wps": 5543.237296688104, "avg_wps": 4738.588957954422, "eta_in_seconds": 1590.4819065069223, "at": "2024-05-25T23:16:15.632869"} +{"lr": 8.13114865359295e-06, "step": 386, "loss": 1.358881950378418, "percent_done": 77.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5532.4391720205385, "avg_wps": 4740.3511170865595, "eta_in_seconds": 1576.0655308992752, "at": "2024-05-25T23:16:27.479870"} +{"lr": 7.995803139546319e-06, "step": 387, "loss": 1.0685631036758423, "percent_done": 77.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5527.543292427566, "avg_wps": 4742.096167620122, "eta_in_seconds": 1561.6655036577574, "at": "2024-05-25T23:16:39.337358"} +{"lr": 7.861420165603275e-06, "step": 388, "loss": 1.5114823579788208, "percent_done": 77.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5533.721451261711, "avg_wps": 4743.845213277877, "eta_in_seconds": 1547.2747676200474, "at": "2024-05-25T23:16:51.181609"} +{"lr": 7.728005610110419e-06, "step": 389, "loss": 1.5361900329589844, "percent_done": 77.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.138672351837158, "wps": 5526.620313930428, "avg_wps": 4745.573104667124, "eta_in_seconds": 1532.901472499867, "at": "2024-05-25T23:17:03.041078"} +{"lr": 7.59556530905263e-06, "step": 390, "loss": 1.2640721797943115, "percent_done": 78.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5539.087447013987, "avg_wps": 4747.316918736619, "eta_in_seconds": 1518.5335471385565, "at": "2024-05-25T23:17:14.873840"} +{"lr": 7.464105055797707e-06, "step": 391, "loss": 1.4845365285873413, "percent_done": 78.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5536.607276339293, "avg_wps": 4749.048420420794, "eta_in_seconds": 1504.1800730612576, "at": "2024-05-25T23:17:26.711932"} +{"lr": 7.333630600843008e-06, "step": 392, "loss": 1.7893493175506592, "percent_done": 78.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1409330368042, "wps": 5532.606871454251, "avg_wps": 4750.76482258026, "eta_in_seconds": 1489.8417969163584, "at": "2024-05-25T23:17:38.558612"} +{"lr": 7.204147651563878e-06, "step": 393, "loss": 1.3601292371749878, "percent_done": 78.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5540.7104105133685, "avg_wps": 4752.488913989457, "eta_in_seconds": 1475.5114902758417, "at": "2024-05-25T23:17:50.387926"} +{"lr": 7.07566187196397e-06, "step": 394, "loss": 1.21010422706604, "percent_done": 78.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139430046081543, "wps": 5538.579628901459, "avg_wps": 4754.201512754854, "eta_in_seconds": 1461.195109496867, "at": "2024-05-25T23:18:02.221782"} +{"lr": 6.948178882427538e-06, "step": 395, "loss": 1.1674048900604248, "percent_done": 79.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.138875007629395, "wps": 5536.00870880737, "avg_wps": 4755.901864172482, "eta_in_seconds": 1446.8927653529977, "at": "2024-05-25T23:18:14.061123"} +{"lr": 6.821704259473511e-06, "step": 396, "loss": 1.3634860515594482, "percent_done": 79.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1392240524292, "wps": 5536.0610002518715, "avg_wps": 4757.594932981414, "eta_in_seconds": 1432.6028373602664, "at": "2024-05-25T23:18:25.900347"} +{"lr": 6.696243535511637e-06, "step": 397, "loss": 1.4827200174331665, "percent_done": 79.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.141201972961426, "wps": 5531.078354273538, "avg_wps": 4759.271385130908, "eta_in_seconds": 1418.328028338382, "at": "2024-05-25T23:18:37.750253"} +{"lr": 6.571802198600406e-06, "step": 398, "loss": 1.3379186391830444, "percent_done": 79.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139405250549316, "wps": 5542.215649922379, "avg_wps": 4760.96127734087, "eta_in_seconds": 1404.0593087397629, "at": "2024-05-25T23:18:49.576350"} +{"lr": 6.4483856922070286e-06, "step": 399, "loss": 1.2363020181655884, "percent_done": 79.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5530.771861911462, "avg_wps": 4762.622666653308, "eta_in_seconds": 1389.809032394175, "at": "2024-05-25T23:19:01.426902"} +{"lr": 6.325999414969323e-06, "step": 400, "loss": 1.4237030744552612, "percent_done": 80.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13873529434204, "wps": 5538.081053278184, "avg_wps": 4764.290441530409, "eta_in_seconds": 1375.5668510198593, "at": "2024-05-25T23:19:13.261812"} +{"lr": 6.2046487204595115e-06, "step": 401, "loss": 1.076772689819336, "percent_done": 80.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1411771774292, "wps": 5606.843480023397, "avg_wps": 4766.076499097849, "eta_in_seconds": 1361.3008522267949, "at": "2024-05-25T23:19:40.077284"} +{"lr": 6.084338916950114e-06, "step": 402, "loss": 1.377065896987915, "percent_done": 80.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5566.783654342226, "avg_wps": 4767.782423341762, "eta_in_seconds": 1347.0681817519724, "at": "2024-05-25T23:19:51.851186"} +{"lr": 5.965075267181666e-06, "step": 403, "loss": 1.2331016063690186, "percent_done": 80.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5548.671726005925, "avg_wps": 4769.447995733995, "eta_in_seconds": 1332.8569691264008, "at": "2024-05-25T23:20:03.663507"} +{"lr": 5.846862988132589e-06, "step": 404, "loss": 1.0951265096664429, "percent_done": 80.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5539.480818928031, "avg_wps": 4771.089629910645, "eta_in_seconds": 1318.6622947843948, "at": "2024-05-25T23:20:15.495393"} +{"lr": 5.7297072507909045e-06, "step": 405, "loss": 1.4920803308486938, "percent_done": 81.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5534.403541143231, "avg_wps": 4772.714964694794, "eta_in_seconds": 1304.48184022197, "at": "2024-05-25T23:20:27.338186"} +{"lr": 5.613613179928103e-06, "step": 406, "loss": 1.2911174297332764, "percent_done": 81.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5526.695652095237, "avg_wps": 4774.319244419228, "eta_in_seconds": 1290.3167309561386, "at": "2024-05-25T23:20:39.197486"} +{"lr": 5.498585853874947e-06, "step": 407, "loss": 1.5607460737228394, "percent_done": 81.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5534.129437121922, "avg_wps": 4775.9303328406495, "eta_in_seconds": 1276.1593187593417, "at": "2024-05-25T23:20:51.040820"} +{"lr": 5.384630304299297e-06, "step": 408, "loss": 1.230184555053711, "percent_done": 81.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5538.970584795458, "avg_wps": 4777.543438708813, "eta_in_seconds": 1262.0109220041948, "at": "2024-05-25T23:21:02.873847"} +{"lr": 5.271751515986073e-06, "step": 409, "loss": 1.7306795120239258, "percent_done": 81.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5534.589301050829, "avg_wps": 4779.141757463665, "eta_in_seconds": 1247.8759372823104, "at": "2024-05-25T23:21:14.716222"} +{"lr": 5.159954426619136e-06, "step": 410, "loss": 1.4807617664337158, "percent_done": 82.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5531.105844536752, "avg_wps": 4780.726998177519, "eta_in_seconds": 1233.7537789228486, "at": "2024-05-25T23:21:26.566047"} +{"lr": 5.049243926565364e-06, "step": 411, "loss": 1.6338636875152588, "percent_done": 82.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5538.592351119124, "avg_wps": 4782.319167994876, "eta_in_seconds": 1219.639215850482, "at": "2024-05-25T23:21:38.399897"} +{"lr": 4.939624858660665e-06, "step": 412, "loss": 1.3516926765441895, "percent_done": 82.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5534.434407402588, "avg_wps": 4783.897127158401, "eta_in_seconds": 1205.5376289886178, "at": "2024-05-25T23:21:50.242641"} +{"lr": 4.831102017998196e-06, "step": 413, "loss": 1.4513237476348877, "percent_done": 82.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5544.145147018787, "avg_wps": 4785.486027677265, "eta_in_seconds": 1191.442617745434, "at": "2024-05-25T23:22:02.064578"} +{"lr": 4.7236801517185786e-06, "step": 414, "loss": 1.3798224925994873, "percent_done": 82.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5538.539677054013, "avg_wps": 4787.058195894252, "eta_in_seconds": 1177.3610784247303, "at": "2024-05-25T23:22:13.898504"} +{"lr": 4.617363958802224e-06, "step": 415, "loss": 1.5379360914230347, "percent_done": 83.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14020013809204, "wps": 5529.878842948535, "avg_wps": 4788.608188254338, "eta_in_seconds": 1163.2941725455134, "at": "2024-05-25T23:22:25.750962"} +{"lr": 4.512158089863847e-06, "step": 416, "loss": 1.8933963775634766, "percent_done": 83.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13971185684204, "wps": 5532.745626480025, "avg_wps": 4790.156893819346, "eta_in_seconds": 1149.2366788868721, "at": "2024-05-25T23:22:37.597286"} +{"lr": 4.408067146948968e-06, "step": 417, "loss": 1.4693549871444702, "percent_done": 83.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14060878753662, "wps": 5542.810195597881, "avg_wps": 4791.717236870136, "eta_in_seconds": 1135.1855151521788, "at": "2024-05-25T23:22:49.422074"} +{"lr": 4.305095683332627e-06, "step": 418, "loss": 1.3827508687973022, "percent_done": 83.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14126491546631, "wps": 5529.436112187818, "avg_wps": 4793.247138794414, "eta_in_seconds": 1121.1506196927796, "at": "2024-05-25T23:23:01.275508"} +{"lr": 4.20324820332023e-06, "step": 419, "loss": 1.205785870552063, "percent_done": 83.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5548.4698999574275, "avg_wps": 4794.804748841511, "eta_in_seconds": 1107.1182828211272, "at": "2024-05-25T23:23:13.088229"} +{"lr": 4.102529162050497e-06, "step": 420, "loss": 1.5002938508987427, "percent_done": 84.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5545.813482066426, "avg_wps": 4796.351218540547, "eta_in_seconds": 1093.0975988024757, "at": "2024-05-25T23:23:24.906675"} +{"lr": 4.002942965300582e-06, "step": 421, "loss": 1.6744729280471802, "percent_done": 84.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5543.668488520225, "avg_wps": 4797.887517488994, "eta_in_seconds": 1079.0882406325352, "at": "2024-05-25T23:23:36.729630"} +{"lr": 3.90449396929334e-06, "step": 422, "loss": 1.101501226425171, "percent_done": 84.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5538.243404104972, "avg_wps": 4799.407867925258, "eta_in_seconds": 1065.0913905781028, "at": "2024-05-25T23:23:48.564191"} +{"lr": 3.8071864805067762e-06, "step": 423, "loss": 1.3566513061523438, "percent_done": 84.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5540.094318244161, "avg_wps": 4800.925274007002, "eta_in_seconds": 1051.1040501549453, "at": "2024-05-25T23:24:00.394820"} +{"lr": 3.711024755485704e-06, "step": 424, "loss": 1.2551512718200684, "percent_done": 84.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5542.924313784657, "avg_wps": 4802.4414884189255, "eta_in_seconds": 1037.1258061157082, "at": "2024-05-25T23:24:12.219363"} +{"lr": 3.6160130006554755e-06, "step": 425, "loss": 1.2069180011749268, "percent_done": 85.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139016151428223, "wps": 5534.400978256311, "avg_wps": 4803.936431805445, "eta_in_seconds": 1023.1609160058639, "at": "2024-05-25T23:24:24.062128"} +{"lr": 3.522155372138053e-06, "step": 426, "loss": 1.1142200231552124, "percent_done": 85.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13873529434204, "wps": 5537.163029679565, "avg_wps": 4805.430166854468, "eta_in_seconds": 1009.2049684647662, "at": "2024-05-25T23:24:35.899037"} +{"lr": 3.4294559755701608e-06, "step": 427, "loss": 1.5559438467025757, "percent_done": 85.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5536.620547093497, "avg_wps": 4806.916870634178, "eta_in_seconds": 995.2591502521301, "at": "2024-05-25T23:24:47.737045"} +{"lr": 3.337918865923721e-06, "step": 428, "loss": 1.4638431072235107, "percent_done": 85.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5542.063457795287, "avg_wps": 4808.407123322748, "eta_in_seconds": 981.3212315390043, "at": "2024-05-25T23:24:59.563431"} +{"lr": 3.2475480473284393e-06, "step": 429, "loss": 1.223836898803711, "percent_done": 85.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1414213180542, "wps": 5529.045500098511, "avg_wps": 4809.868435917796, "eta_in_seconds": 967.3977702286415, "at": "2024-05-25T23:25:11.417679"} +{"lr": 3.158347472896674e-06, "step": 430, "loss": 1.508067011833191, "percent_done": 86.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5552.6900207191175, "avg_wps": 4811.36529515232, "eta_in_seconds": 953.4757222907488, "at": "2024-05-25T23:25:23.221448"} +{"lr": 3.0703210445505373e-06, "step": 431, "loss": 1.4822466373443604, "percent_done": 86.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5541.777533517647, "avg_wps": 4812.837074971461, "eta_in_seconds": 939.5672302135458, "at": "2024-05-25T23:25:35.048424"} +{"lr": 2.9834726128511543e-06, "step": 432, "loss": 1.2388511896133423, "percent_done": 86.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14012050628662, "wps": 5537.369053691516, "avg_wps": 4814.295227857319, "eta_in_seconds": 925.6698621665989, "at": "2024-05-25T23:25:46.884836"} +{"lr": 2.897805976830286e-06, "step": 433, "loss": 1.2354152202606201, "percent_done": 86.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.138790130615234, "wps": 5534.54405783707, "avg_wps": 4815.742586240146, "eta_in_seconds": 911.7829537953296, "at": "2024-05-25T23:25:58.727314"} +{"lr": 2.8133248838241186e-06, "step": 434, "loss": 1.3420536518096924, "percent_done": 86.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14108180999756, "wps": 5521.232854084343, "avg_wps": 4817.160847962765, "eta_in_seconds": 897.9098137919254, "at": "2024-05-25T23:26:10.598317"} +{"lr": 2.7300330293093305e-06, "step": 435, "loss": 1.7331186532974243, "percent_done": 87.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5534.876044331215, "avg_wps": 4818.597248682247, "eta_in_seconds": 884.0415125304255, "at": "2024-05-25T23:26:22.440061"} +{"lr": 2.6479340567414757e-06, "step": 436, "loss": 1.6415690183639526, "percent_done": 87.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139389991760254, "wps": 5547.253878420293, "avg_wps": 4820.049393327249, "eta_in_seconds": 870.1786346435547, "at": "2024-05-25T23:26:34.255378"} +{"lr": 2.5670315573955692e-06, "step": 437, "loss": 1.2258780002593994, "percent_done": 87.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5546.94100147263, "avg_wps": 4821.4952205979325, "eta_in_seconds": 856.325229227952, "at": "2024-05-25T23:26:46.071406"} +{"lr": 2.48732907020903e-06, "step": 438, "loss": 1.1916077136993408, "percent_done": 87.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139499187469482, "wps": 5545.094906692296, "avg_wps": 4822.93212020207, "eta_in_seconds": 842.481689298534, "at": "2024-05-25T23:26:57.891361"} +{"lr": 2.4088300816268335e-06, "step": 439, "loss": 1.5336813926696777, "percent_done": 87.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.138530731201172, "wps": 5540.11441697168, "avg_wps": 4824.354729162702, "eta_in_seconds": 828.6488503497391, "at": "2024-05-25T23:27:09.721966"} +{"lr": 2.3315380254490547e-06, "step": 440, "loss": 1.52827787399292, "percent_done": 88.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5529.080087951019, "avg_wps": 4825.752639766269, "eta_in_seconds": 814.8283373659307, "at": "2024-05-25T23:27:21.576167"} +{"lr": 2.2554562826806213e-06, "step": 441, "loss": 1.4440735578536987, "percent_done": 88.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5542.894023386682, "avg_wps": 4827.168831674929, "eta_in_seconds": 801.0127954564127, "at": "2024-05-25T23:27:33.400790"} +{"lr": 2.1805881813834265e-06, "step": 442, "loss": 1.4471334218978882, "percent_done": 88.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139073848724365, "wps": 5537.265314725364, "avg_wps": 4828.5697675933225, "eta_in_seconds": 787.2078447557682, "at": "2024-05-25T23:27:45.237424"} +{"lr": 2.106936996530766e-06, "step": 443, "loss": 1.413780689239502, "percent_done": 88.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5540.2174810711995, "avg_wps": 4829.970254248535, "eta_in_seconds": 773.4109742630685, "at": "2024-05-25T23:27:57.067804"} +{"lr": 2.034505949864056e-06, "step": 444, "loss": 1.568229079246521, "percent_done": 88.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5539.475907015981, "avg_wps": 4831.363969229035, "eta_in_seconds": 759.6231671582472, "at": "2024-05-25T23:28:08.899756"} +{"lr": 1.9632982097519294e-06, "step": 445, "loss": 1.2987884283065796, "percent_done": 89.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5531.397235866023, "avg_wps": 4832.738381756317, "eta_in_seconds": 745.8462915366955, "at": "2024-05-25T23:28:20.748962"} +{"lr": 1.8933168910516103e-06, "step": 446, "loss": 1.2623353004455566, "percent_done": 89.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13873529434204, "wps": 5533.95674324649, "avg_wps": 4834.111789051965, "eta_in_seconds": 732.0774021020385, "at": "2024-05-25T23:28:32.592677"} +{"lr": 1.8245650549726923e-06, "step": 447, "loss": 1.3227944374084473, "percent_done": 89.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5544.433440514158, "avg_wps": 4835.49768790479, "eta_in_seconds": 718.3144785051112, "at": "2024-05-25T23:28:44.414020"} +{"lr": 1.757045708943213e-06, "step": 448, "loss": 1.8180917501449585, "percent_done": 89.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1396541595459, "wps": 5538.572375031584, "avg_wps": 4836.868222076985, "eta_in_seconds": 704.5616798996925, "at": "2024-05-25T23:28:56.247919"} +{"lr": 1.6907618064780943e-06, "step": 449, "loss": 1.5383700132369995, "percent_done": 89.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139648914337158, "wps": 5537.020595403856, "avg_wps": 4838.230785310016, "eta_in_seconds": 690.8178109543892, "at": "2024-05-25T23:29:08.085102"} +{"lr": 1.625716247049965e-06, "step": 450, "loss": 1.5726405382156372, "percent_done": 90.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13873529434204, "wps": 5534.567793716583, "avg_wps": 4839.58388961061, "eta_in_seconds": 677.083004395167, "at": "2024-05-25T23:29:19.927528"} +{"lr": 1.5619118759623072e-06, "step": 451, "loss": 1.229055404663086, "percent_done": 90.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5537.345851520766, "avg_wps": 4840.936455656658, "eta_in_seconds": 663.35594970424, "at": "2024-05-25T23:29:31.763999"} +{"lr": 1.4993514842250177e-06, "step": 452, "loss": 1.3133533000946045, "percent_done": 90.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5536.939398876936, "avg_wps": 4842.2831004232, "eta_in_seconds": 649.6373579902987, "at": "2024-05-25T23:29:43.601340"} +{"lr": 1.4380378084322957e-06, "step": 453, "loss": 1.1959723234176636, "percent_done": 90.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14009380340576, "wps": 5533.535638209661, "avg_wps": 4843.618790749949, "eta_in_seconds": 635.9278326945063, "at": "2024-05-25T23:29:55.445992"} +{"lr": 1.37797353064294e-06, "step": 454, "loss": 1.4957315921783447, "percent_done": 90.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1392240524292, "wps": 5527.092155814596, "avg_wps": 4844.938436304245, "eta_in_seconds": 622.2279270693069, "at": "2024-05-25T23:30:07.304292"} +{"lr": 1.319161278263055e-06, "step": 455, "loss": 1.2987531423568726, "percent_done": 91.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1384916305542, "wps": 5533.508569363958, "avg_wps": 4846.263824964534, "eta_in_seconds": 608.5347613161737, "at": "2024-05-25T23:30:19.148845"} +{"lr": 1.261603623931077e-06, "step": 456, "loss": 1.779760718345642, "percent_done": 91.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139268398284912, "wps": 5537.596065956076, "avg_wps": 4847.590995297616, "eta_in_seconds": 594.8488646829337, "at": "2024-05-25T23:30:30.984704"} +{"lr": 1.205303085405276e-06, "step": 457, "loss": 1.1598193645477295, "percent_done": 91.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1399564743042, "wps": 5529.567366678185, "avg_wps": 4848.899590022369, "eta_in_seconds": 581.1726862314754, "at": "2024-05-25T23:30:42.837739"} +{"lr": 1.1502621254535857e-06, "step": 458, "loss": 1.7242182493209839, "percent_done": 91.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5535.512602459266, "avg_wps": 4850.213148865603, "eta_in_seconds": 567.503306662672, "at": "2024-05-25T23:30:54.678085"} +{"lr": 1.0964831517459112e-06, "step": 459, "loss": 1.4536421298980713, "percent_done": 91.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5538.07558595897, "avg_wps": 4851.525978558798, "eta_in_seconds": 553.8414123463475, "at": "2024-05-25T23:31:06.512881"} +{"lr": 1.0439685167487763e-06, "step": 460, "loss": 1.2507259845733643, "percent_done": 92.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1411771774292, "wps": 5541.388527230523, "avg_wps": 4852.839333307466, "eta_in_seconds": 540.1868514392687, "at": "2024-05-25T23:31:18.340633"} +{"lr": 9.927205176224375e-07, "step": 461, "loss": 1.3502042293548584, "percent_done": 92.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5539.462957471421, "avg_wps": 4854.144490597286, "eta_in_seconds": 526.5405685699943, "at": "2024-05-25T23:31:30.172495"} +{"lr": 9.427413961204031e-07, "step": 462, "loss": 1.4290932416915894, "percent_done": 92.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13957977294922, "wps": 5534.486557677176, "avg_wps": 4855.4364125667935, "eta_in_seconds": 512.9030201187381, "at": "2024-05-25T23:31:42.014967"} +{"lr": 8.940333384913533e-07, "step": 463, "loss": 1.162807822227478, "percent_done": 92.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1411771774292, "wps": 5541.743568701974, "avg_wps": 4856.735491565326, "eta_in_seconds": 499.271991281221, "at": "2024-05-25T23:31:53.841921"} +{"lr": 8.465984753835264e-07, "step": 464, "loss": 1.526496410369873, "percent_done": 92.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5534.90713876165, "avg_wps": 4858.018325554442, "eta_in_seconds": 485.6498765328835, "at": "2024-05-25T23:32:05.683498"} +{"lr": 8.004388817514974e-07, "step": 465, "loss": 1.6751914024353027, "percent_done": 93.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5541.382718245516, "avg_wps": 4859.307036709747, "eta_in_seconds": 472.0343832303119, "at": "2024-05-25T23:32:17.511332"} +{"lr": 7.555565767654276e-07, "step": 466, "loss": 1.8657950162887573, "percent_done": 93.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.140678882598877, "wps": 5540.418260501413, "avg_wps": 4860.589303797008, "eta_in_seconds": 458.42671757092296, "at": "2024-05-25T23:32:29.341241"} +{"lr": 7.119535237227388e-07, "step": 467, "loss": 1.3259780406951904, "percent_done": 93.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5541.7370886199615, "avg_wps": 4861.868926085916, "eta_in_seconds": 444.82647164679696, "at": "2024-05-25T23:32:41.168314"} +{"lr": 6.696316299622224e-07, "step": 468, "loss": 1.1357439756393433, "percent_done": 93.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5528.122019903643, "avg_wps": 4863.121290926681, "eta_in_seconds": 431.2357999198457, "at": "2024-05-25T23:32:53.024499"} +{"lr": 6.285927467806198e-07, "step": 469, "loss": 1.483215570449829, "percent_done": 93.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5536.983565923128, "avg_wps": 4864.383562723774, "eta_in_seconds": 417.6512756042643, "at": "2024-05-25T23:33:04.861725"} +{"lr": 5.888386693516242e-07, "step": 470, "loss": 1.3447225093841553, "percent_done": 94.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 2818.414741643536, "avg_wps": 4856.881964494165, "eta_in_seconds": 404.80291972769066, "at": "2024-05-25T23:33:28.140354"} +{"lr": 5.503711366473705e-07, "step": 471, "loss": 1.2989805936813354, "percent_done": 94.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5565.773708553193, "avg_wps": 4858.195701616006, "eta_in_seconds": 391.20367245967725, "at": "2024-05-25T23:33:39.916395"} +{"lr": 5.131918313623563e-07, "step": 472, "loss": 1.4937809705734253, "percent_done": 94.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5541.998091496166, "avg_wps": 4859.466014763509, "eta_in_seconds": 377.61515245195164, "at": "2024-05-25T23:33:51.742938"} +{"lr": 4.773023798398375e-07, "step": 473, "loss": 1.5734940767288208, "percent_done": 94.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13873529434204, "wps": 5539.568676644442, "avg_wps": 4860.727664124924, "eta_in_seconds": 364.03438379396596, "at": "2024-05-25T23:34:03.574673"} +{"lr": 4.4270435200069295e-07, "step": 474, "loss": 1.2783210277557373, "percent_done": 94.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5540.620618010061, "avg_wps": 4861.986350468246, "eta_in_seconds": 350.46087692860306, "at": "2024-05-25T23:34:15.404144"} +{"lr": 4.0939926127473865e-07, "step": 475, "loss": 1.5040833950042725, "percent_done": 95.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5534.530239860128, "avg_wps": 4863.230495788966, "eta_in_seconds": 336.8954034604524, "at": "2024-05-25T23:34:27.246698"} +{"lr": 3.7738856453453507e-07, "step": 476, "loss": 1.4859583377838135, "percent_done": 95.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139155387878418, "wps": 5531.467583980725, "avg_wps": 4864.46507324175, "eta_in_seconds": 323.3375050119993, "at": "2024-05-25T23:34:39.095749"} +{"lr": 3.4667366203166475e-07, "step": 477, "loss": 1.377013087272644, "percent_done": 95.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5527.310990665434, "avg_wps": 4865.688349634892, "eta_in_seconds": 309.787206184939, "at": "2024-05-25T23:34:50.953697"} +{"lr": 3.172558973354582e-07, "step": 478, "loss": 1.727473258972168, "percent_done": 95.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5528.57488139409, "avg_wps": 4866.909168814225, "eta_in_seconds": 296.24386853952285, "at": "2024-05-25T23:35:02.808942"} +{"lr": 2.8913655727425123e-07, "step": 479, "loss": 1.2657310962677002, "percent_done": 95.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13897943496704, "wps": 5522.30968311067, "avg_wps": 4868.115346713984, "eta_in_seconds": 282.7081738991628, "at": "2024-05-25T23:35:14.677633"} +{"lr": 2.623168718790634e-07, "step": 480, "loss": 1.3324154615402222, "percent_done": 96.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5539.5219007153655, "avg_wps": 4869.344886513437, "eta_in_seconds": 269.17789364854497, "at": "2024-05-25T23:35:26.509479"} +{"lr": 2.3679801432982478e-07, "step": 481, "loss": 1.4634283781051636, "percent_done": 96.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5533.054787905231, "avg_wps": 4870.559525187848, "eta_in_seconds": 255.65522678874882, "at": "2024-05-25T23:35:38.355185"} +{"lr": 2.1258110090402713e-07, "step": 482, "loss": 1.1581710577011108, "percent_done": 96.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5533.8807613556955, "avg_wps": 4871.771054529839, "eta_in_seconds": 242.1394574572931, "at": "2024-05-25T23:35:50.199074"} +{"lr": 1.896671909279231e-07, "step": 483, "loss": 1.384340763092041, "percent_done": 96.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5536.405769426682, "avg_wps": 4872.982218114612, "eta_in_seconds": 228.63042591422732, "at": "2024-05-25T23:36:02.037548"} +{"lr": 1.6805728673016362e-07, "step": 484, "loss": 1.2824896574020386, "percent_done": 96.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1389799118042, "wps": 5534.988832962237, "avg_wps": 4874.186705841601, "eta_in_seconds": 215.12840259961845, "at": "2024-05-25T23:36:13.879042"} +{"lr": 1.477523335979629e-07, "step": 485, "loss": 1.3915427923202515, "percent_done": 97.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13929796218872, "wps": 5530.157866487155, "avg_wps": 4875.379083605387, "eta_in_seconds": 201.6335515951373, "at": "2024-05-25T23:36:25.730955"} +{"lr": 1.2875321973575205e-07, "step": 486, "loss": 1.7751845121383667, "percent_done": 97.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.13979434967041, "wps": 5517.335469256387, "avg_wps": 4876.546571104314, "eta_in_seconds": 188.14626019089312, "at": "2024-05-25T23:36:37.610398"} +{"lr": 1.1106077622631656e-07, "step": 487, "loss": 1.3046096563339233, "percent_done": 97.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5530.925437716181, "avg_wps": 4877.731576689974, "eta_in_seconds": 174.66479788913375, "at": "2024-05-25T23:36:49.460632"} +{"lr": 9.467577699445256e-08, "step": 488, "loss": 1.3110491037368774, "percent_done": 97.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5537.196603743627, "avg_wps": 4878.922286422781, "eta_in_seconds": 161.18969596800258, "at": "2024-05-25T23:37:01.297432"} +{"lr": 7.959893877311043e-08, "step": 489, "loss": 1.4425559043884277, "percent_done": 97.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5533.1076918270655, "avg_wps": 4880.10220431381, "eta_in_seconds": 147.72149635775202, "at": "2024-05-25T23:37:13.143006"} +{"lr": 6.58309210720302e-08, "step": 490, "loss": 1.190127968788147, "percent_done": 98.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5536.834003090966, "avg_wps": 4881.283788090012, "eta_in_seconds": 134.25976207304973, "at": "2024-05-25T23:37:24.980578"} +{"lr": 5.337232614891126e-08, "step": 491, "loss": 1.4984546899795532, "percent_done": 98.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139284133911133, "wps": 5540.317422294481, "avg_wps": 4882.466640951081, "eta_in_seconds": 120.8045120171277, "at": "2024-05-25T23:37:36.810755"} +{"lr": 4.222369898305362e-08, "step": 492, "loss": 1.3258860111236572, "percent_done": 98.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5531.842284623181, "avg_wps": 4883.6318504608325, "eta_in_seconds": 107.35616771573943, "at": "2024-05-25T23:37:48.659041"} +{"lr": 3.2385527251530405e-08, "step": 493, "loss": 1.438199758529663, "percent_done": 98.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1397123336792, "wps": 5535.22545883186, "avg_wps": 4884.798233541129, "eta_in_seconds": 93.9142167326403, "at": "2024-05-25T23:38:00.500070"} +{"lr": 2.385824130784165e-08, "step": 494, "loss": 1.260614275932312, "percent_done": 98.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1387357711792, "wps": 5536.991373302559, "avg_wps": 4885.963232735457, "eta_in_seconds": 80.47870630001732, "at": "2024-05-25T23:38:12.337279"} +{"lr": 1.6642214163099443e-08, "step": 495, "loss": 1.3144422769546509, "percent_done": 99.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1409330368042, "wps": 5527.284538401669, "avg_wps": 4887.108773774314, "eta_in_seconds": 67.04986837175157, "at": "2024-05-25T23:38:24.195333"} +{"lr": 1.0737761469707708e-08, "step": 496, "loss": 1.1841107606887817, "percent_done": 99.2, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1402006149292, "wps": 5524.8966534966985, "avg_wps": 4888.246462675485, "eta_in_seconds": 53.62741056565316, "at": "2024-05-25T23:38:36.058509"} +{"lr": 6.145141507556636e-09, "step": 497, "loss": 1.244451642036438, "percent_done": 99.4, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5528.994675647007, "avg_wps": 4889.38655288693, "eta_in_seconds": 40.21117943393393, "at": "2024-05-25T23:38:47.912875"} +{"lr": 2.864555172718443e-09, "step": 498, "loss": 1.3902086019515991, "percent_done": 99.6, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.1404447555542, "wps": 5532.748076470777, "avg_wps": 4890.52848592629, "eta_in_seconds": 26.80119344508313, "at": "2024-05-25T23:38:59.759170"} +{"lr": 8.961459686677561e-10, "step": 499, "loss": 1.4591144323349, "percent_done": 99.8, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.139838218688965, "wps": 5530.526158362615, "avg_wps": 4891.662890367311, "eta_in_seconds": 13.397489047958283, "at": "2024-05-25T23:39:11.610269"} +{"lr": 2.4e-10, "step": 500, "loss": 1.562139868736267, "percent_done": 100.0, "peak_allocated_mem": 64.85545778274536, "allocated_mem": 24.14044427871704, "wps": 5528.798504252308, "avg_wps": 4892.790575206737, "eta_in_seconds": 0.0, "at": "2024-05-25T23:39:23.465087"} diff --git a/runseed5/tb/events.out.tfevents.1716673602.scw-tender-archimedes.43269.0.train b/runseed5/tb/events.out.tfevents.1716673602.scw-tender-archimedes.43269.0.train new file mode 100644 index 0000000000000000000000000000000000000000..18df22ec461b915133b2cbbcc6ef35c808b91154 --- /dev/null +++ b/runseed5/tb/events.out.tfevents.1716673602.scw-tender-archimedes.43269.0.train @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:da08a4fc711866282126cecf6b7b024a0555bb08d2e801c1ceded02735ea92a0 +size 215572 diff --git a/runseed5/tb/events.out.tfevents.1716673604.scw-tender-archimedes.43269.1.eval b/runseed5/tb/events.out.tfevents.1716673604.scw-tender-archimedes.43269.1.eval new file mode 100644 index 0000000000000000000000000000000000000000..28cca256cb90b71eadbeeefbab0053faebd9bf9e --- /dev/null +++ b/runseed5/tb/events.out.tfevents.1716673604.scw-tender-archimedes.43269.1.eval @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:28fefdd308b0c0830e549a8a82080c8de4a0d9d8bd3bd90768784ea8787ab84c +size 88 diff --git a/runseed5/wandb/debug-internal.log b/runseed5/wandb/debug-internal.log new file mode 120000 index 0000000000000000000000000000000000000000..e64a019c972419960aa321b06cc957edffcbb21d --- /dev/null +++ b/runseed5/wandb/debug-internal.log @@ -0,0 +1 @@ +run-20240525_214643-cngfo6vp/logs/debug-internal.log \ No newline at end of file diff --git a/runseed5/wandb/debug.log b/runseed5/wandb/debug.log new file mode 120000 index 0000000000000000000000000000000000000000..c701b6574d1d650887a6bed7c8d806c50782abbd --- /dev/null +++ b/runseed5/wandb/debug.log @@ -0,0 +1 @@ +run-20240525_214643-cngfo6vp/logs/debug.log \ No newline at end of file diff --git a/runseed5/wandb/latest-run b/runseed5/wandb/latest-run new file mode 120000 index 0000000000000000000000000000000000000000..7490986b7f3064207cce18241334d88298372e61 --- /dev/null +++ b/runseed5/wandb/latest-run @@ -0,0 +1 @@ +run-20240525_214643-cngfo6vp \ No newline at end of file diff --git a/runseed5/wandb/run-20240525_214643-cngfo6vp/files/conda-environment.yaml b/runseed5/wandb/run-20240525_214643-cngfo6vp/files/conda-environment.yaml new file mode 100644 index 0000000000000000000000000000000000000000..b872d6a32156b541e625a9e137de272c9701a8f3 --- /dev/null +++ b/runseed5/wandb/run-20240525_214643-cngfo6vp/files/conda-environment.yaml @@ -0,0 +1,92 @@ +name: chemistralpy310 +channels: + - defaults +dependencies: + - _libgcc_mutex=0.1=main + - _openmp_mutex=5.1=1_gnu + - bzip2=1.0.8=h5eee18b_6 + - ca-certificates=2024.3.11=h06a4308_0 + - ld_impl_linux-64=2.38=h1181459_1 + - libffi=3.4.4=h6a678d5_1 + - libgcc-ng=11.2.0=h1234567_1 + - libgomp=11.2.0=h1234567_1 + - libstdcxx-ng=11.2.0=h1234567_1 + - libuuid=1.41.5=h5eee18b_0 + - ncurses=6.4=h6a678d5_0 + - openssl=3.0.13=h7f8727e_2 + - pip=24.0=py310h06a4308_0 + - python=3.10.14=h955ad1f_1 + - readline=8.2=h5eee18b_0 + - setuptools=69.5.1=py310h06a4308_0 + - sqlite=3.45.3=h5eee18b_0 + - tk=8.6.14=h39e8969_0 + - tzdata=2024a=h04d1e81_0 + - wheel=0.43.0=py310h06a4308_0 + - xz=5.4.6=h5eee18b_1 + - zlib=1.2.13=h5eee18b_1 + - pip: + - absl-py==2.1.0 + - annotated-types==0.7.0 + - attrs==23.2.0 + - certifi==2024.2.2 + - charset-normalizer==3.3.2 + - click==8.1.7 + - docker-pycreds==0.4.0 + - docstring-parser==0.16 + - filelock==3.14.0 + - fire==0.6.0 + - fsspec==2024.5.0 + - gitdb==4.0.11 + - gitpython==3.1.43 + - grpcio==1.64.0 + - idna==3.7 + - jinja2==3.1.4 + - jsonschema==4.21.1 + - jsonschema-specifications==2023.12.1 + - markdown==3.6 + - markupsafe==2.1.5 + - mistral-common==1.1.0 + - mpmath==1.3.0 + - networkx==3.3 + - numpy==1.26.4 + - nvidia-cublas-cu12==12.1.3.1 + - nvidia-cuda-cupti-cu12==12.1.105 + - nvidia-cuda-nvrtc-cu12==12.1.105 + - nvidia-cuda-runtime-cu12==12.1.105 + - nvidia-cudnn-cu12==8.9.2.26 + - nvidia-cufft-cu12==11.0.2.54 + - nvidia-curand-cu12==10.3.2.106 + - nvidia-cusolver-cu12==11.4.5.107 + - nvidia-cusparse-cu12==12.1.0.106 + - nvidia-nccl-cu12==2.19.3 + - nvidia-nvjitlink-cu12==12.5.40 + - nvidia-nvtx-cu12==12.1.105 + - platformdirs==4.2.2 + - protobuf==4.25.3 + - psutil==5.9.8 + - pydantic==2.6.1 + - pydantic-core==2.16.2 + - pyyaml==6.0.1 + - referencing==0.35.1 + - requests==2.32.2 + - rpds-py==0.18.1 + - safetensors==0.4.3 + - sentencepiece==0.1.99 + - sentry-sdk==2.3.1 + - setproctitle==1.3.3 + - simple-parsing==0.1.5 + - six==1.16.0 + - smmap==5.0.1 + - sympy==1.12 + - tensorboard==2.16.2 + - tensorboard-data-server==0.7.2 + - termcolor==2.4.0 + - torch==2.2.0 + - tqdm==4.66.4 + - triton==2.2.0 + - typing-extensions==4.12.0 + - urllib3==2.2.1 + - wandb==0.17.0 + - werkzeug==3.0.3 + - xformers==0.0.24 +prefix: /root/miniconda/envs/chemistralpy310 diff --git a/runseed5/wandb/run-20240525_214643-cngfo6vp/files/config.yaml b/runseed5/wandb/run-20240525_214643-cngfo6vp/files/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..841fe05b1112a26b6f38f5827a4a6a3b6b8b978e --- /dev/null +++ b/runseed5/wandb/run-20240525_214643-cngfo6vp/files/config.yaml @@ -0,0 +1,115 @@ +wandb_version: 1 + +data: + desc: null + value: + data: '' + shuffle: false + instruct_data: /root/data/mol_instructions_train.jsonl + eval_instruct_data: '' + instruct: + shuffle: true + dynamic_chunk_fn_call: true +model_id_or_path: + desc: null + value: /root/mistral_models/7B-v0.3 +run_dir: + desc: null + value: /root/mistral-finetune/runseed5 +optim: + desc: null + value: + lr: 6.0e-05 + weight_decay: 0.1 + pct_start: 0.05 +seed: + desc: null + value: 5 +num_microbatches: + desc: null + value: 1 +seq_len: + desc: null + value: 32768 +batch_size: + desc: null + value: 2 +max_norm: + desc: null + value: 1.0 +max_steps: + desc: null + value: 500 +log_freq: + desc: null + value: 1 +ckpt_freq: + desc: null + value: 100 +ckpt_only_lora: + desc: null + value: false +no_ckpt: + desc: null + value: false +num_ckpt_keep: + desc: null + value: 3 +eval_freq: + desc: null + value: 100 +no_eval: + desc: null + value: true +checkpoint: + desc: null + value: true +world_size: + desc: null + value: 1 +wandb: + desc: null + value: + project: CHEMISTral7b-ft + offline: false + key: aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df + run_name: run1 +mlflow: + desc: null + value: + tracking_uri: null + experiment_name: null +lora: + desc: null + value: + enable: true + rank: 64 + dropout: 0.0 + scaling: 2.0 +_wandb: + desc: null + value: + python_version: 3.10.14 + cli_version: 0.17.0 + framework: torch + is_jupyter_run: false + is_kaggle_kernel: false + start_time: 1716673603 + t: + 1: + - 1 + - 55 + 2: + - 1 + - 55 + 3: + - 2 + - 13 + - 16 + - 23 + - 61 + 4: 3.10.14 + 5: 0.17.0 + 8: + - 5 + 13: linux-x86_64 diff --git a/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log b/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log new file mode 100644 index 0000000000000000000000000000000000000000..95bea7f0f4fa5b561d0e7a14276c05b9360fa785 --- /dev/null +++ b/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log @@ -0,0 +1,537 @@ + +wandb: WARNING Calling wandb.login() after wandb.init() has no effect. +2024-05-25 21:46:44 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Reloading model from /root/mistral_models/7B-v0.3/consolidated.safetensors ... +2024-05-25 21:46:45 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Converting model to dtype torch.bfloat16 ... +2024-05-25 21:46:45 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Loaded model on cpu! +2024-05-25 21:46:45 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Initializing lora layers ... +2024-05-25 21:46:45 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Finished initialization! +2024-05-25 21:46:45 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Sharding model over 1 GPUs ... +2024-05-25 21:46:46 (UTC) - 0:00:06 - finetune.wrapped_model - INFO - Model sharded! +2024-05-25 21:46:46 (UTC) - 0:00:06 - finetune.wrapped_model - INFO - 167,772,160 out of 7,415,795,712 parameter are finetuned (2.26%). +2024-05-25 21:46:47 (UTC) - 0:00:06 - dataset - INFO - Loading /root/data/mol_instructions_train.jsonl ... +2024-05-25 21:58:58 (UTC) - 0:12:17 - dataset - INFO - /root/data/mol_instructions_train.jsonl loaded and tokenized. +2024-05-25 21:58:58 (UTC) - 0:12:17 - dataset - INFO - Shuffling /root/data/mol_instructions_train.jsonl ... +2024-05-25 21:59:10 (UTC) - 0:12:29 - train - INFO - step: 000001 - done (%): 0.2 - loss: 2.263 - lr: 2.4e-06 - peak_alloc_mem (GB): 63.6 - alloc_mem (GB): 24.1 - words_per_second: 88.2 - avg_words_per_second: 88.2 - ETA: >2024-05-30 05:01:07 +2024-05-25 21:59:21 (UTC) - 0:12:41 - train - INFO - step: 000002 - done (%): 0.4 - loss: 2.109 - lr: 2.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5641.7 - avg_words_per_second: 173.6 - ETA: >2024-05-28 02:12:21 +2024-05-25 21:59:33 (UTC) - 0:12:53 - train - INFO - step: 000003 - done (%): 0.6 - loss: 1.950 - lr: 3.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5581.8 - avg_words_per_second: 256.4 - ETA: >2024-05-27 09:16:26 +2024-05-25 21:59:45 (UTC) - 0:13:04 - train - INFO - step: 000004 - done (%): 0.8 - loss: 2.137 - lr: 4.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5568.7 - avg_words_per_second: 336.8 - ETA: >2024-05-27 00:48:32 +2024-05-25 21:59:57 (UTC) - 0:13:16 - train - INFO - step: 000005 - done (%): 1.0 - loss: 2.457 - lr: 6.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5556.7 - avg_words_per_second: 414.7 - ETA: >2024-05-26 19:43:51 +2024-05-25 22:00:09 (UTC) - 0:13:28 - train - INFO - step: 000006 - done (%): 1.2 - loss: 2.165 - lr: 8.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.8 - avg_words_per_second: 490.3 - ETA: >2024-05-26 16:20:46 +2024-05-25 22:00:20 (UTC) - 0:13:40 - train - INFO - step: 000007 - done (%): 1.4 - loss: 1.872 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.2 - avg_words_per_second: 563.7 - ETA: >2024-05-26 13:55:42 +2024-05-25 22:00:32 (UTC) - 0:13:52 - train - INFO - step: 000008 - done (%): 1.6 - loss: 2.180 - lr: 1.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.1 - avg_words_per_second: 634.9 - ETA: >2024-05-26 12:06:56 +2024-05-25 22:00:44 (UTC) - 0:14:04 - train - INFO - step: 000009 - done (%): 1.8 - loss: 2.058 - lr: 1.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.5 - avg_words_per_second: 704.2 - ETA: >2024-05-26 10:42:19 +2024-05-25 22:00:56 (UTC) - 0:14:15 - train - INFO - step: 000010 - done (%): 2.0 - loss: 1.883 - lr: 2.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.4 - avg_words_per_second: 771.5 - ETA: >2024-05-26 09:34:37 +2024-05-25 22:01:08 (UTC) - 0:14:27 - train - INFO - step: 000011 - done (%): 2.2 - loss: 2.233 - lr: 2.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.7 - avg_words_per_second: 837.0 - ETA: >2024-05-26 08:39:14 +2024-05-25 22:01:20 (UTC) - 0:14:39 - train - INFO - step: 000012 - done (%): 2.4 - loss: 1.842 - lr: 2.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.7 - avg_words_per_second: 900.8 - ETA: >2024-05-26 07:53:05 +2024-05-25 22:01:31 (UTC) - 0:14:51 - train - INFO - step: 000013 - done (%): 2.6 - loss: 1.745 - lr: 3.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.8 - avg_words_per_second: 962.8 - ETA: >2024-05-26 07:14:02 +2024-05-25 22:01:43 (UTC) - 0:15:03 - train - INFO - step: 000014 - done (%): 2.8 - loss: 1.583 - lr: 3.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.3 - avg_words_per_second: 1023.2 - ETA: >2024-05-26 06:40:33 +2024-05-25 22:01:55 (UTC) - 0:15:15 - train - INFO - step: 000015 - done (%): 3.0 - loss: 1.855 - lr: 3.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.3 - avg_words_per_second: 1081.9 - ETA: >2024-05-26 06:11:33 +2024-05-25 22:02:07 (UTC) - 0:15:26 - train - INFO - step: 000016 - done (%): 3.2 - loss: 1.853 - lr: 4.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.1 - avg_words_per_second: 1139.2 - ETA: >2024-05-26 05:46:10 +2024-05-25 22:02:19 (UTC) - 0:15:38 - train - INFO - step: 000017 - done (%): 3.4 - loss: 1.730 - lr: 4.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.8 - avg_words_per_second: 1195.0 - ETA: >2024-05-26 05:23:47 +2024-05-25 22:02:31 (UTC) - 0:15:50 - train - INFO - step: 000018 - done (%): 3.6 - loss: 2.016 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.9 - avg_words_per_second: 1249.4 - ETA: >2024-05-26 05:03:53 +2024-05-25 22:02:43 (UTC) - 0:16:02 - train - INFO - step: 000019 - done (%): 3.8 - loss: 1.916 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5518.7 - avg_words_per_second: 1302.5 - ETA: >2024-05-26 04:46:05 +2024-05-25 22:02:54 (UTC) - 0:16:14 - train - INFO - step: 000020 - done (%): 4.0 - loss: 1.929 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.0 - avg_words_per_second: 1354.2 - ETA: >2024-05-26 04:30:03 +2024-05-25 22:03:06 (UTC) - 0:16:26 - train - INFO - step: 000021 - done (%): 4.2 - loss: 1.996 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.3 - avg_words_per_second: 1404.7 - ETA: >2024-05-26 04:15:33 +2024-05-25 22:03:18 (UTC) - 0:16:38 - train - INFO - step: 000022 - done (%): 4.4 - loss: 1.654 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5546.2 - avg_words_per_second: 1454.1 - ETA: >2024-05-26 04:02:21 +2024-05-25 22:03:30 (UTC) - 0:16:49 - train - INFO - step: 000023 - done (%): 4.6 - loss: 1.767 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.0 - avg_words_per_second: 1502.3 - ETA: >2024-05-26 03:50:19 +2024-05-25 22:03:42 (UTC) - 0:17:01 - train - INFO - step: 000024 - done (%): 4.8 - loss: 1.335 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.7 - avg_words_per_second: 1549.3 - ETA: >2024-05-26 03:39:17 +2024-05-25 22:03:54 (UTC) - 0:17:13 - train - INFO - step: 000025 - done (%): 5.0 - loss: 1.706 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5545.5 - avg_words_per_second: 1595.3 - ETA: >2024-05-26 03:29:07 +2024-05-25 22:04:05 (UTC) - 0:17:25 - train - INFO - step: 000026 - done (%): 5.2 - loss: 1.464 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.4 - avg_words_per_second: 1640.2 - ETA: >2024-05-26 03:19:44 +2024-05-25 22:04:17 (UTC) - 0:17:37 - train - INFO - step: 000027 - done (%): 5.4 - loss: 2.187 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.6 - avg_words_per_second: 1684.1 - ETA: >2024-05-26 03:11:03 +2024-05-25 22:04:29 (UTC) - 0:17:49 - train - INFO - step: 000028 - done (%): 5.6 - loss: 1.759 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.5 - avg_words_per_second: 1727.1 - ETA: >2024-05-26 03:03:00 +2024-05-25 22:04:41 (UTC) - 0:18:00 - train - INFO - step: 000029 - done (%): 5.8 - loss: 2.010 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.9 - avg_words_per_second: 1769.0 - ETA: >2024-05-26 02:55:30 +2024-05-25 22:04:53 (UTC) - 0:18:12 - train - INFO - step: 000030 - done (%): 6.0 - loss: 1.866 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.7 - avg_words_per_second: 1810.1 - ETA: >2024-05-26 02:48:30 +2024-05-25 22:05:05 (UTC) - 0:18:24 - train - INFO - step: 000031 - done (%): 6.2 - loss: 1.404 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.2 - avg_words_per_second: 1850.2 - ETA: >2024-05-26 02:41:57 +2024-05-25 22:05:16 (UTC) - 0:18:36 - train - INFO - step: 000032 - done (%): 6.4 - loss: 1.771 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.4 - avg_words_per_second: 1889.5 - ETA: >2024-05-26 02:35:48 +2024-05-25 22:05:28 (UTC) - 0:18:48 - train - INFO - step: 000033 - done (%): 6.6 - loss: 1.608 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.1 - avg_words_per_second: 1928.0 - ETA: >2024-05-26 02:30:02 +2024-05-25 22:05:40 (UTC) - 0:19:00 - train - INFO - step: 000034 - done (%): 6.8 - loss: 1.839 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5548.0 - avg_words_per_second: 1965.7 - ETA: >2024-05-26 02:24:36 +2024-05-25 22:05:52 (UTC) - 0:19:11 - train - INFO - step: 000035 - done (%): 7.0 - loss: 1.840 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5546.4 - avg_words_per_second: 2002.7 - ETA: >2024-05-26 02:19:29 +2024-05-25 22:06:04 (UTC) - 0:19:23 - train - INFO - step: 000036 - done (%): 7.2 - loss: 1.752 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.6 - avg_words_per_second: 2038.8 - ETA: >2024-05-26 02:14:39 +2024-05-25 22:06:16 (UTC) - 0:19:35 - train - INFO - step: 000037 - done (%): 7.4 - loss: 1.734 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.8 - avg_words_per_second: 2074.3 - ETA: >2024-05-26 02:10:04 +2024-05-25 22:06:27 (UTC) - 0:19:47 - train - INFO - step: 000038 - done (%): 7.6 - loss: 1.343 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5548.5 - avg_words_per_second: 2109.0 - ETA: >2024-05-26 02:05:44 +2024-05-25 22:06:39 (UTC) - 0:19:59 - train - INFO - step: 000039 - done (%): 7.8 - loss: 1.416 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.7 - avg_words_per_second: 2143.0 - ETA: >2024-05-26 02:01:37 +2024-05-25 22:06:51 (UTC) - 0:20:11 - train - INFO - step: 000040 - done (%): 8.0 - loss: 1.722 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.4 - avg_words_per_second: 2176.4 - ETA: >2024-05-26 01:57:43 +2024-05-25 22:07:03 (UTC) - 0:20:22 - train - INFO - step: 000041 - done (%): 8.2 - loss: 1.533 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.3 - avg_words_per_second: 2209.1 - ETA: >2024-05-26 01:54:00 +2024-05-25 22:07:15 (UTC) - 0:20:34 - train - INFO - step: 000042 - done (%): 8.4 - loss: 1.118 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.7 - avg_words_per_second: 2241.1 - ETA: >2024-05-26 01:50:28 +2024-05-25 22:07:27 (UTC) - 0:20:46 - train - INFO - step: 000043 - done (%): 8.6 - loss: 1.211 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5545.1 - avg_words_per_second: 2272.6 - ETA: >2024-05-26 01:47:05 +2024-05-25 22:07:38 (UTC) - 0:20:58 - train - INFO - step: 000044 - done (%): 8.8 - loss: 1.766 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.5 - avg_words_per_second: 2303.5 - ETA: >2024-05-26 01:43:52 +2024-05-25 22:07:50 (UTC) - 0:21:10 - train - INFO - step: 000045 - done (%): 9.0 - loss: 1.289 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.6 - avg_words_per_second: 2333.8 - ETA: >2024-05-26 01:40:47 +2024-05-25 22:08:02 (UTC) - 0:21:22 - train - INFO - step: 000046 - done (%): 9.2 - loss: 1.433 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.4 - avg_words_per_second: 2363.4 - ETA: >2024-05-26 01:37:51 +2024-05-25 22:08:14 (UTC) - 0:21:33 - train - INFO - step: 000047 - done (%): 9.4 - loss: 1.980 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.4 - avg_words_per_second: 2392.6 - ETA: >2024-05-26 01:35:02 +2024-05-25 22:08:26 (UTC) - 0:21:45 - train - INFO - step: 000048 - done (%): 9.6 - loss: 1.427 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.2 - avg_words_per_second: 2421.3 - ETA: >2024-05-26 01:32:20 +2024-05-25 22:08:38 (UTC) - 0:21:57 - train - INFO - step: 000049 - done (%): 9.8 - loss: 1.911 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5520.6 - avg_words_per_second: 2449.3 - ETA: >2024-05-26 01:29:45 +2024-05-25 22:08:49 (UTC) - 0:22:09 - train - INFO - step: 000050 - done (%): 10.0 - loss: 1.665 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.2 - avg_words_per_second: 2477.0 - ETA: >2024-05-26 01:27:16 +2024-05-25 22:09:01 (UTC) - 0:22:21 - train - INFO - step: 000051 - done (%): 10.2 - loss: 1.698 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.1 - avg_words_per_second: 2504.1 - ETA: >2024-05-26 01:24:52 +2024-05-25 22:09:13 (UTC) - 0:22:33 - train - INFO - step: 000052 - done (%): 10.4 - loss: 1.842 - lr: 6.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.2 - avg_words_per_second: 2530.8 - ETA: >2024-05-26 01:22:34 +2024-05-25 22:09:25 (UTC) - 0:22:45 - train - INFO - step: 000053 - done (%): 10.6 - loss: 1.687 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5519.1 - avg_words_per_second: 2556.9 - ETA: >2024-05-26 01:20:22 +2024-05-25 22:09:37 (UTC) - 0:22:56 - train - INFO - step: 000054 - done (%): 10.8 - loss: 1.535 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.7 - avg_words_per_second: 2582.6 - ETA: >2024-05-26 01:18:14 +2024-05-25 22:09:49 (UTC) - 0:23:08 - train - INFO - step: 000055 - done (%): 11.0 - loss: 1.665 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.7 - avg_words_per_second: 2607.9 - ETA: >2024-05-26 01:16:11 +2024-05-25 22:10:01 (UTC) - 0:23:20 - train - INFO - step: 000056 - done (%): 11.2 - loss: 1.546 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.3 - avg_words_per_second: 2632.8 - ETA: >2024-05-26 01:14:13 +2024-05-25 22:10:12 (UTC) - 0:23:32 - train - INFO - step: 000057 - done (%): 11.4 - loss: 1.264 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.3 - avg_words_per_second: 2657.2 - ETA: >2024-05-26 01:12:19 +2024-05-25 22:10:24 (UTC) - 0:23:44 - train - INFO - step: 000058 - done (%): 11.6 - loss: 1.767 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.6 - avg_words_per_second: 2681.2 - ETA: >2024-05-26 01:10:28 +2024-05-25 22:10:36 (UTC) - 0:23:56 - train - INFO - step: 000059 - done (%): 11.8 - loss: 1.575 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.5 - avg_words_per_second: 2704.8 - ETA: >2024-05-26 01:08:41 +2024-05-25 22:10:48 (UTC) - 0:24:07 - train - INFO - step: 000060 - done (%): 12.0 - loss: 1.494 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.6 - avg_words_per_second: 2728.0 - ETA: >2024-05-26 01:06:58 +2024-05-25 22:11:00 (UTC) - 0:24:19 - train - INFO - step: 000061 - done (%): 12.2 - loss: 1.311 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.3 - avg_words_per_second: 2750.9 - ETA: >2024-05-26 01:05:18 +2024-05-25 22:11:12 (UTC) - 0:24:31 - train - INFO - step: 000062 - done (%): 12.4 - loss: 1.547 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.0 - avg_words_per_second: 2773.4 - ETA: >2024-05-26 01:03:42 +2024-05-25 22:11:24 (UTC) - 0:24:43 - train - INFO - step: 000063 - done (%): 12.6 - loss: 1.388 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.7 - avg_words_per_second: 2795.5 - ETA: >2024-05-26 01:02:08 +2024-05-25 22:11:35 (UTC) - 0:24:55 - train - INFO - step: 000064 - done (%): 12.8 - loss: 1.444 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.0 - avg_words_per_second: 2817.3 - ETA: >2024-05-26 01:00:37 +2024-05-25 22:11:47 (UTC) - 0:25:07 - train - INFO - step: 000065 - done (%): 13.0 - loss: 1.568 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.0 - avg_words_per_second: 2838.8 - ETA: >2024-05-26 00:59:10 +2024-05-25 22:11:59 (UTC) - 0:25:19 - train - INFO - step: 000066 - done (%): 13.2 - loss: 1.897 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.4 - avg_words_per_second: 2859.9 - ETA: >2024-05-26 00:57:44 +2024-05-25 22:12:11 (UTC) - 0:25:30 - train - INFO - step: 000067 - done (%): 13.4 - loss: 1.747 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.4 - avg_words_per_second: 2880.7 - ETA: >2024-05-26 00:56:22 +2024-05-25 22:12:23 (UTC) - 0:25:42 - train - INFO - step: 000068 - done (%): 13.6 - loss: 1.768 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.4 - avg_words_per_second: 2901.1 - ETA: >2024-05-26 00:55:02 +2024-05-25 22:12:35 (UTC) - 0:25:54 - train - INFO - step: 000069 - done (%): 13.8 - loss: 1.864 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.5 - avg_words_per_second: 2921.3 - ETA: >2024-05-26 00:53:44 +2024-05-25 22:12:46 (UTC) - 0:26:06 - train - INFO - step: 000070 - done (%): 14.0 - loss: 2.062 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.0 - avg_words_per_second: 2941.1 - ETA: >2024-05-26 00:52:28 +2024-05-25 22:12:58 (UTC) - 0:26:18 - train - INFO - step: 000071 - done (%): 14.2 - loss: 1.725 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.1 - avg_words_per_second: 2960.6 - ETA: >2024-05-26 00:51:15 +2024-05-25 22:13:10 (UTC) - 0:26:30 - train - INFO - step: 000072 - done (%): 14.4 - loss: 1.606 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.4 - avg_words_per_second: 2979.9 - ETA: >2024-05-26 00:50:03 +2024-05-25 22:13:22 (UTC) - 0:26:41 - train - INFO - step: 000073 - done (%): 14.6 - loss: 1.569 - lr: 5.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.0 - avg_words_per_second: 2998.8 - ETA: >2024-05-26 00:48:53 +2024-05-25 22:13:34 (UTC) - 0:26:53 - train - INFO - step: 000074 - done (%): 14.8 - loss: 1.465 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.7 - avg_words_per_second: 3017.5 - ETA: >2024-05-26 00:47:46 +2024-05-25 22:13:46 (UTC) - 0:27:05 - train - INFO - step: 000075 - done (%): 15.0 - loss: 1.454 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5547.9 - avg_words_per_second: 3036.0 - ETA: >2024-05-26 00:46:40 +2024-05-25 22:13:57 (UTC) - 0:27:17 - train - INFO - step: 000076 - done (%): 15.2 - loss: 1.920 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5523.7 - avg_words_per_second: 3054.1 - ETA: >2024-05-26 00:45:36 +2024-05-25 22:14:09 (UTC) - 0:27:29 - train - INFO - step: 000077 - done (%): 15.4 - loss: 1.780 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.4 - avg_words_per_second: 3072.0 - ETA: >2024-05-26 00:44:33 +2024-05-25 22:14:21 (UTC) - 0:27:41 - train - INFO - step: 000078 - done (%): 15.6 - loss: 1.528 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.1 - avg_words_per_second: 3089.6 - ETA: >2024-05-26 00:43:32 +2024-05-25 22:14:33 (UTC) - 0:27:53 - train - INFO - step: 000079 - done (%): 15.8 - loss: 1.356 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5519.3 - avg_words_per_second: 3106.9 - ETA: >2024-05-26 00:42:33 +2024-05-25 22:14:45 (UTC) - 0:28:04 - train - INFO - step: 000080 - done (%): 16.0 - loss: 1.569 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5518.3 - avg_words_per_second: 3124.0 - ETA: >2024-05-26 00:41:36 +2024-05-25 22:14:57 (UTC) - 0:28:16 - train - INFO - step: 000081 - done (%): 16.2 - loss: 1.661 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.2 - avg_words_per_second: 3140.9 - ETA: >2024-05-26 00:40:39 +2024-05-25 22:15:09 (UTC) - 0:28:28 - train - INFO - step: 000082 - done (%): 16.4 - loss: 1.819 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.2 - avg_words_per_second: 3157.5 - ETA: >2024-05-26 00:39:44 +2024-05-25 22:15:20 (UTC) - 0:28:40 - train - INFO - step: 000083 - done (%): 16.6 - loss: 1.794 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.2 - avg_words_per_second: 3174.0 - ETA: >2024-05-26 00:38:51 +2024-05-25 22:15:32 (UTC) - 0:28:52 - train - INFO - step: 000084 - done (%): 16.8 - loss: 1.383 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.8 - avg_words_per_second: 3190.1 - ETA: >2024-05-26 00:37:58 +2024-05-25 22:15:44 (UTC) - 0:29:04 - train - INFO - step: 000085 - done (%): 17.0 - loss: 1.682 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.8 - avg_words_per_second: 3206.1 - ETA: >2024-05-26 00:37:07 +2024-05-25 22:15:56 (UTC) - 0:29:15 - train - INFO - step: 000086 - done (%): 17.2 - loss: 1.368 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.6 - avg_words_per_second: 3221.8 - ETA: >2024-05-26 00:36:17 +2024-05-25 22:16:08 (UTC) - 0:29:27 - train - INFO - step: 000087 - done (%): 17.4 - loss: 1.722 - lr: 5.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.4 - avg_words_per_second: 3237.4 - ETA: >2024-05-26 00:35:28 +2024-05-25 22:16:20 (UTC) - 0:29:39 - train - INFO - step: 000088 - done (%): 17.6 - loss: 1.316 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.6 - avg_words_per_second: 3252.7 - ETA: >2024-05-26 00:34:41 +2024-05-25 22:16:32 (UTC) - 0:29:51 - train - INFO - step: 000089 - done (%): 17.8 - loss: 1.563 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.0 - avg_words_per_second: 3267.8 - ETA: >2024-05-26 00:33:54 +2024-05-25 22:16:43 (UTC) - 0:30:03 - train - INFO - step: 000090 - done (%): 18.0 - loss: 1.668 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.6 - avg_words_per_second: 3282.7 - ETA: >2024-05-26 00:33:09 +2024-05-25 22:16:55 (UTC) - 0:30:15 - train - INFO - step: 000091 - done (%): 18.2 - loss: 1.548 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.2 - avg_words_per_second: 3297.5 - ETA: >2024-05-26 00:32:24 +2024-05-25 22:17:07 (UTC) - 0:30:27 - train - INFO - step: 000092 - done (%): 18.4 - loss: 1.400 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5499.0 - avg_words_per_second: 3311.9 - ETA: >2024-05-26 00:31:41 +2024-05-25 22:17:19 (UTC) - 0:30:39 - train - INFO - step: 000093 - done (%): 18.6 - loss: 1.345 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.6 - avg_words_per_second: 3326.2 - ETA: >2024-05-26 00:30:58 +2024-05-25 22:17:31 (UTC) - 0:30:50 - train - INFO - step: 000094 - done (%): 18.8 - loss: 1.508 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.1 - avg_words_per_second: 3340.4 - ETA: >2024-05-26 00:30:16 +2024-05-25 22:17:43 (UTC) - 0:31:02 - train - INFO - step: 000095 - done (%): 19.0 - loss: 1.449 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.2 - avg_words_per_second: 3354.4 - ETA: >2024-05-26 00:29:35 +2024-05-25 22:17:55 (UTC) - 0:31:14 - train - INFO - step: 000096 - done (%): 19.2 - loss: 1.544 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5518.6 - avg_words_per_second: 3368.2 - ETA: >2024-05-26 00:28:55 +2024-05-25 22:18:06 (UTC) - 0:31:26 - train - INFO - step: 000097 - done (%): 19.4 - loss: 1.485 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.8 - avg_words_per_second: 3381.8 - ETA: >2024-05-26 00:28:16 +2024-05-25 22:18:18 (UTC) - 0:31:38 - train - INFO - step: 000098 - done (%): 19.6 - loss: 1.486 - lr: 5.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.5 - avg_words_per_second: 3395.3 - ETA: >2024-05-26 00:27:38 +2024-05-25 22:18:30 (UTC) - 0:31:50 - train - INFO - step: 000099 - done (%): 19.8 - loss: 1.477 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5521.5 - avg_words_per_second: 3408.5 - ETA: >2024-05-26 00:27:00 +2024-05-25 22:18:42 (UTC) - 0:32:01 - train - INFO - step: 000100 - done (%): 20.0 - loss: 1.588 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.2 - avg_words_per_second: 3421.7 - ETA: >2024-05-26 00:26:23 +2024-05-25 22:18:42 (UTC) - 0:32:01 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runseed5/checkpoints/checkpoint_000100/consolidated using tmp name: tmp.consolidated +2024-05-25 22:18:57 (UTC) - 0:32:16 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runseed5/checkpoints/checkpoint_000100/consolidated for step: 100 +2024-05-25 22:18:57 (UTC) - 0:32:16 - checkpointing - INFO - Done deleting checkpoints +2024-05-25 22:18:57 (UTC) - 0:32:16 - checkpointing - INFO - Done! +2024-05-25 22:19:08 (UTC) - 0:32:28 - train - INFO - step: 000101 - done (%): 20.2 - loss: 1.442 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5599.0 - avg_words_per_second: 3434.9 - ETA: >2024-05-26 00:26:01 +2024-05-25 22:19:20 (UTC) - 0:32:40 - train - INFO - step: 000102 - done (%): 20.4 - loss: 1.662 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5550.8 - avg_words_per_second: 3447.8 - ETA: >2024-05-26 00:25:26 +2024-05-25 22:19:32 (UTC) - 0:32:52 - train - INFO - step: 000103 - done (%): 20.6 - loss: 1.788 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5548.2 - avg_words_per_second: 3460.5 - ETA: >2024-05-26 00:24:51 +2024-05-25 22:19:44 (UTC) - 0:33:03 - train - INFO - step: 000104 - done (%): 20.8 - loss: 1.665 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.1 - avg_words_per_second: 3473.0 - ETA: >2024-05-26 00:24:16 +2024-05-25 22:19:56 (UTC) - 0:33:15 - train - INFO - step: 000105 - done (%): 21.0 - loss: 1.484 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.1 - avg_words_per_second: 3485.4 - ETA: >2024-05-26 00:23:43 +2024-05-25 22:20:08 (UTC) - 0:33:27 - train - INFO - step: 000106 - done (%): 21.2 - loss: 1.726 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5507.1 - avg_words_per_second: 3497.5 - ETA: >2024-05-26 00:23:10 +2024-05-25 22:20:29 (UTC) - 0:33:48 - train - INFO - step: 000107 - done (%): 21.4 - loss: 1.233 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 3116.6 - avg_words_per_second: 3493.5 - ETA: >2024-05-26 00:23:21 +2024-05-25 22:20:40 (UTC) - 0:34:00 - train - INFO - step: 000108 - done (%): 21.6 - loss: 1.670 - lr: 5.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5559.8 - avg_words_per_second: 3505.5 - ETA: >2024-05-26 00:22:49 +2024-05-25 22:20:52 (UTC) - 0:34:12 - train - INFO - step: 000109 - done (%): 21.8 - loss: 1.436 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.8 - avg_words_per_second: 3517.4 - ETA: >2024-05-26 00:22:17 +2024-05-25 22:21:04 (UTC) - 0:34:24 - train - INFO - step: 000110 - done (%): 22.0 - loss: 1.359 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.5 - avg_words_per_second: 3529.0 - ETA: >2024-05-26 00:21:47 +2024-05-25 22:21:16 (UTC) - 0:34:35 - train - INFO - step: 000111 - done (%): 22.2 - loss: 1.491 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.2 - avg_words_per_second: 3540.6 - ETA: >2024-05-26 00:21:16 +2024-05-25 22:21:28 (UTC) - 0:34:47 - train - INFO - step: 000112 - done (%): 22.4 - loss: 1.686 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.4 - avg_words_per_second: 3552.0 - ETA: >2024-05-26 00:20:47 +2024-05-25 22:21:40 (UTC) - 0:34:59 - train - INFO - step: 000113 - done (%): 22.6 - loss: 1.728 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.8 - avg_words_per_second: 3563.3 - ETA: >2024-05-26 00:20:17 +2024-05-25 22:21:52 (UTC) - 0:35:11 - train - INFO - step: 000114 - done (%): 22.8 - loss: 1.405 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.2 - avg_words_per_second: 3574.5 - ETA: >2024-05-26 00:19:49 +2024-05-25 22:22:03 (UTC) - 0:35:23 - train - INFO - step: 000115 - done (%): 23.0 - loss: 1.556 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.3 - avg_words_per_second: 3585.6 - ETA: >2024-05-26 00:19:20 +2024-05-25 22:22:15 (UTC) - 0:35:35 - train - INFO - step: 000116 - done (%): 23.2 - loss: 1.701 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.0 - avg_words_per_second: 3596.5 - ETA: >2024-05-26 00:18:53 +2024-05-25 22:22:27 (UTC) - 0:35:47 - train - INFO - step: 000117 - done (%): 23.4 - loss: 1.831 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.0 - avg_words_per_second: 3607.3 - ETA: >2024-05-26 00:18:25 +2024-05-25 22:22:39 (UTC) - 0:35:58 - train - INFO - step: 000118 - done (%): 23.6 - loss: 1.781 - lr: 5.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.8 - avg_words_per_second: 3617.9 - ETA: >2024-05-26 00:17:59 +2024-05-25 22:22:51 (UTC) - 0:36:10 - train - INFO - step: 000119 - done (%): 23.8 - loss: 1.469 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.2 - avg_words_per_second: 3628.5 - ETA: >2024-05-26 00:17:32 +2024-05-25 22:23:03 (UTC) - 0:36:22 - train - INFO - step: 000120 - done (%): 24.0 - loss: 1.558 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.2 - avg_words_per_second: 3638.9 - ETA: >2024-05-26 00:17:06 +2024-05-25 22:23:14 (UTC) - 0:36:34 - train - INFO - step: 000121 - done (%): 24.2 - loss: 1.552 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.4 - avg_words_per_second: 3649.2 - ETA: >2024-05-26 00:16:41 +2024-05-25 22:23:26 (UTC) - 0:36:46 - train - INFO - step: 000122 - done (%): 24.4 - loss: 1.649 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.2 - avg_words_per_second: 3659.4 - ETA: >2024-05-26 00:16:16 +2024-05-25 22:23:38 (UTC) - 0:36:58 - train - INFO - step: 000123 - done (%): 24.6 - loss: 1.553 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.2 - avg_words_per_second: 3669.5 - ETA: >2024-05-26 00:15:51 +2024-05-25 22:23:50 (UTC) - 0:37:10 - train - INFO - step: 000124 - done (%): 24.8 - loss: 1.558 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.5 - avg_words_per_second: 3679.5 - ETA: >2024-05-26 00:15:27 +2024-05-25 22:24:02 (UTC) - 0:37:21 - train - INFO - step: 000125 - done (%): 25.0 - loss: 1.484 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.5 - avg_words_per_second: 3689.4 - ETA: >2024-05-26 00:15:03 +2024-05-25 22:24:14 (UTC) - 0:37:33 - train - INFO - step: 000126 - done (%): 25.2 - loss: 1.549 - lr: 5.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5523.7 - avg_words_per_second: 3699.1 - ETA: >2024-05-26 00:14:40 +2024-05-25 22:24:26 (UTC) - 0:37:45 - train - INFO - step: 000127 - done (%): 25.4 - loss: 1.463 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.2 - avg_words_per_second: 3708.8 - ETA: >2024-05-26 00:14:17 +2024-05-25 22:24:37 (UTC) - 0:37:57 - train - INFO - step: 000128 - done (%): 25.6 - loss: 1.713 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.2 - avg_words_per_second: 3718.4 - ETA: >2024-05-26 00:13:54 +2024-05-25 22:24:49 (UTC) - 0:38:09 - train - INFO - step: 000129 - done (%): 25.8 - loss: 1.561 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.6 - avg_words_per_second: 3727.8 - ETA: >2024-05-26 00:13:32 +2024-05-25 22:25:01 (UTC) - 0:38:21 - train - INFO - step: 000130 - done (%): 26.0 - loss: 1.553 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5523.5 - avg_words_per_second: 3737.2 - ETA: >2024-05-26 00:13:10 +2024-05-25 22:25:13 (UTC) - 0:38:33 - train - INFO - step: 000131 - done (%): 26.2 - loss: 1.657 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.3 - avg_words_per_second: 3746.4 - ETA: >2024-05-26 00:12:48 +2024-05-25 22:25:25 (UTC) - 0:38:44 - train - INFO - step: 000132 - done (%): 26.4 - loss: 1.358 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5516.8 - avg_words_per_second: 3755.6 - ETA: >2024-05-26 00:12:27 +2024-05-25 22:25:37 (UTC) - 0:38:56 - train - INFO - step: 000133 - done (%): 26.6 - loss: 1.431 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.3 - avg_words_per_second: 3764.7 - ETA: >2024-05-26 00:12:06 +2024-05-25 22:25:49 (UTC) - 0:39:08 - train - INFO - step: 000134 - done (%): 26.8 - loss: 1.530 - lr: 5.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.8 - avg_words_per_second: 3773.6 - ETA: >2024-05-26 00:11:45 +2024-05-25 22:26:00 (UTC) - 0:39:20 - train - INFO - step: 000135 - done (%): 27.0 - loss: 1.812 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.1 - avg_words_per_second: 3782.5 - ETA: >2024-05-26 00:11:24 +2024-05-25 22:26:12 (UTC) - 0:39:32 - train - INFO - step: 000136 - done (%): 27.2 - loss: 1.475 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5489.8 - avg_words_per_second: 3791.2 - ETA: >2024-05-26 00:11:05 +2024-05-25 22:26:24 (UTC) - 0:39:44 - train - INFO - step: 000137 - done (%): 27.4 - loss: 1.614 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.6 - avg_words_per_second: 3799.9 - ETA: >2024-05-26 00:10:45 +2024-05-25 22:26:36 (UTC) - 0:39:56 - train - INFO - step: 000138 - done (%): 27.6 - loss: 1.572 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5523.9 - avg_words_per_second: 3808.5 - ETA: >2024-05-26 00:10:25 +2024-05-25 22:26:48 (UTC) - 0:40:07 - train - INFO - step: 000139 - done (%): 27.8 - loss: 1.490 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.8 - avg_words_per_second: 3817.1 - ETA: >2024-05-26 00:10:06 +2024-05-25 22:27:00 (UTC) - 0:40:19 - train - INFO - step: 000140 - done (%): 28.0 - loss: 1.505 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.5 - avg_words_per_second: 3825.6 - ETA: >2024-05-26 00:09:47 +2024-05-25 22:27:12 (UTC) - 0:40:31 - train - INFO - step: 000141 - done (%): 28.2 - loss: 1.820 - lr: 5.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.9 - avg_words_per_second: 3834.0 - ETA: >2024-05-26 00:09:28 +2024-05-25 22:27:23 (UTC) - 0:40:43 - train - INFO - step: 000142 - done (%): 28.4 - loss: 1.471 - lr: 5.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.2 - avg_words_per_second: 3842.3 - ETA: >2024-05-26 00:09:10 +2024-05-25 22:27:35 (UTC) - 0:40:55 - train - INFO - step: 000143 - done (%): 28.6 - loss: 1.500 - lr: 5.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.3 - avg_words_per_second: 3850.5 - ETA: >2024-05-26 00:08:52 +2024-05-25 22:27:47 (UTC) - 0:41:07 - train - INFO - step: 000144 - done (%): 28.8 - loss: 1.642 - lr: 5.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.9 - avg_words_per_second: 3858.6 - ETA: >2024-05-26 00:08:34 +2024-05-25 22:27:59 (UTC) - 0:41:19 - train - INFO - step: 000145 - done (%): 29.0 - loss: 1.583 - lr: 5.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.1 - avg_words_per_second: 3866.7 - ETA: >2024-05-26 00:08:16 +2024-05-25 22:28:11 (UTC) - 0:41:30 - train - INFO - step: 000146 - done (%): 29.2 - loss: 1.742 - lr: 5.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.2 - avg_words_per_second: 3874.7 - ETA: >2024-05-26 00:07:58 +2024-05-25 22:28:23 (UTC) - 0:41:42 - train - INFO - step: 000147 - done (%): 29.4 - loss: 1.363 - lr: 5.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.7 - avg_words_per_second: 3882.6 - ETA: >2024-05-26 00:07:41 +2024-05-25 22:28:35 (UTC) - 0:41:54 - train - INFO - step: 000148 - done (%): 29.6 - loss: 1.411 - lr: 5.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.8 - avg_words_per_second: 3890.4 - ETA: >2024-05-26 00:07:24 +2024-05-25 22:28:46 (UTC) - 0:42:06 - train - INFO - step: 000149 - done (%): 29.8 - loss: 1.933 - lr: 5.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.5 - avg_words_per_second: 3898.2 - ETA: >2024-05-26 00:07:07 +2024-05-25 22:28:58 (UTC) - 0:42:18 - train - INFO - step: 000150 - done (%): 30.0 - loss: 1.431 - lr: 5.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.7 - avg_words_per_second: 3905.9 - ETA: >2024-05-26 00:06:51 +2024-05-25 22:29:10 (UTC) - 0:42:30 - train - INFO - step: 000151 - done (%): 30.2 - loss: 1.497 - lr: 5.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.7 - avg_words_per_second: 3913.5 - ETA: >2024-05-26 00:06:35 +2024-05-25 22:29:22 (UTC) - 0:42:41 - train - INFO - step: 000152 - done (%): 30.4 - loss: 1.454 - lr: 5.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.1 - avg_words_per_second: 3921.0 - ETA: >2024-05-26 00:06:18 +2024-05-25 22:29:34 (UTC) - 0:42:53 - train - INFO - step: 000153 - done (%): 30.6 - loss: 1.803 - lr: 5.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.4 - avg_words_per_second: 3928.5 - ETA: >2024-05-26 00:06:02 +2024-05-25 22:29:46 (UTC) - 0:43:05 - train - INFO - step: 000154 - done (%): 30.8 - loss: 1.592 - lr: 5.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.2 - avg_words_per_second: 3936.0 - ETA: >2024-05-26 00:05:47 +2024-05-25 22:29:58 (UTC) - 0:43:17 - train - INFO - step: 000155 - done (%): 31.0 - loss: 1.214 - lr: 5.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.1 - avg_words_per_second: 3943.3 - ETA: >2024-05-26 00:05:31 +2024-05-25 22:30:09 (UTC) - 0:43:29 - train - INFO - step: 000156 - done (%): 31.2 - loss: 1.805 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.8 - avg_words_per_second: 3950.6 - ETA: >2024-05-26 00:05:16 +2024-05-25 22:30:21 (UTC) - 0:43:41 - train - INFO - step: 000157 - done (%): 31.4 - loss: 1.654 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.0 - avg_words_per_second: 3957.7 - ETA: >2024-05-26 00:05:01 +2024-05-25 22:30:33 (UTC) - 0:43:53 - train - INFO - step: 000158 - done (%): 31.6 - loss: 1.611 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.6 - avg_words_per_second: 3964.9 - ETA: >2024-05-26 00:04:46 +2024-05-25 22:30:45 (UTC) - 0:44:04 - train - INFO - step: 000159 - done (%): 31.8 - loss: 1.289 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.1 - avg_words_per_second: 3972.0 - ETA: >2024-05-26 00:04:31 +2024-05-25 22:30:57 (UTC) - 0:44:16 - train - INFO - step: 000160 - done (%): 32.0 - loss: 1.586 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.7 - avg_words_per_second: 3979.0 - ETA: >2024-05-26 00:04:17 +2024-05-25 22:31:09 (UTC) - 0:44:28 - train - INFO - step: 000161 - done (%): 32.2 - loss: 1.071 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.4 - avg_words_per_second: 3985.9 - ETA: >2024-05-26 00:04:02 +2024-05-25 22:31:20 (UTC) - 0:44:40 - train - INFO - step: 000162 - done (%): 32.4 - loss: 1.221 - lr: 4.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.2 - avg_words_per_second: 3992.8 - ETA: >2024-05-26 00:03:48 +2024-05-25 22:31:32 (UTC) - 0:44:52 - train - INFO - step: 000163 - done (%): 32.6 - loss: 1.836 - lr: 4.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.4 - avg_words_per_second: 3999.7 - ETA: >2024-05-26 00:03:34 +2024-05-25 22:31:44 (UTC) - 0:45:04 - train - INFO - step: 000164 - done (%): 32.8 - loss: 1.346 - lr: 4.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.9 - avg_words_per_second: 4006.4 - ETA: >2024-05-26 00:03:20 +2024-05-25 22:31:56 (UTC) - 0:45:15 - train - INFO - step: 000165 - done (%): 33.0 - loss: 1.512 - lr: 4.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.4 - avg_words_per_second: 4013.2 - ETA: >2024-05-26 00:03:07 +2024-05-25 22:32:08 (UTC) - 0:45:27 - train - INFO - step: 000166 - done (%): 33.2 - loss: 1.333 - lr: 4.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.4 - avg_words_per_second: 4019.9 - ETA: >2024-05-26 00:02:53 +2024-05-25 22:32:20 (UTC) - 0:45:39 - train - INFO - step: 000167 - done (%): 33.4 - loss: 1.385 - lr: 4.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.1 - avg_words_per_second: 4026.5 - ETA: >2024-05-26 00:02:40 +2024-05-25 22:32:31 (UTC) - 0:45:51 - train - INFO - step: 000168 - done (%): 33.6 - loss: 1.322 - lr: 4.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.8 - avg_words_per_second: 4033.1 - ETA: >2024-05-26 00:02:26 +2024-05-25 22:32:43 (UTC) - 0:46:03 - train - INFO - step: 000169 - done (%): 33.8 - loss: 1.431 - lr: 4.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.8 - avg_words_per_second: 4039.6 - ETA: >2024-05-26 00:02:13 +2024-05-25 22:32:55 (UTC) - 0:46:15 - train - INFO - step: 000170 - done (%): 34.0 - loss: 1.323 - lr: 4.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.5 - avg_words_per_second: 4046.0 - ETA: >2024-05-26 00:02:00 +2024-05-25 22:33:07 (UTC) - 0:46:26 - train - INFO - step: 000171 - done (%): 34.2 - loss: 1.423 - lr: 4.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.0 - avg_words_per_second: 4052.3 - ETA: >2024-05-26 00:01:48 +2024-05-25 22:33:19 (UTC) - 0:46:38 - train - INFO - step: 000172 - done (%): 34.4 - loss: 1.501 - lr: 4.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.7 - avg_words_per_second: 4058.7 - ETA: >2024-05-26 00:01:35 +2024-05-25 22:33:31 (UTC) - 0:46:50 - train - INFO - step: 000173 - done (%): 34.6 - loss: 1.224 - lr: 4.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.4 - avg_words_per_second: 4064.9 - ETA: >2024-05-26 00:01:23 +2024-05-25 22:33:42 (UTC) - 0:47:02 - train - INFO - step: 000174 - done (%): 34.8 - loss: 1.043 - lr: 4.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.0 - avg_words_per_second: 4071.1 - ETA: >2024-05-26 00:01:10 +2024-05-25 22:33:54 (UTC) - 0:47:14 - train - INFO - step: 000175 - done (%): 35.0 - loss: 1.325 - lr: 4.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.0 - avg_words_per_second: 4077.3 - ETA: >2024-05-26 00:00:58 +2024-05-25 22:34:06 (UTC) - 0:47:26 - train - INFO - step: 000176 - done (%): 35.2 - loss: 1.284 - lr: 4.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.9 - avg_words_per_second: 4083.4 - ETA: >2024-05-26 00:00:46 +2024-05-25 22:34:18 (UTC) - 0:47:38 - train - INFO - step: 000177 - done (%): 35.4 - loss: 1.670 - lr: 4.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.7 - avg_words_per_second: 4089.4 - ETA: >2024-05-26 00:00:34 +2024-05-25 22:34:30 (UTC) - 0:47:49 - train - INFO - step: 000178 - done (%): 35.6 - loss: 1.206 - lr: 4.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.0 - avg_words_per_second: 4095.4 - ETA: >2024-05-26 00:00:23 +2024-05-25 22:34:42 (UTC) - 0:48:01 - train - INFO - step: 000179 - done (%): 35.8 - loss: 1.472 - lr: 4.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5499.3 - avg_words_per_second: 4101.3 - ETA: >2024-05-26 00:00:11 +2024-05-25 22:34:54 (UTC) - 0:48:13 - train - INFO - step: 000180 - done (%): 36.0 - loss: 1.396 - lr: 4.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.0 - avg_words_per_second: 4107.2 - ETA: >2024-05-26 00:00:00 +2024-05-25 22:35:06 (UTC) - 0:48:25 - train - INFO - step: 000181 - done (%): 36.2 - loss: 1.497 - lr: 4.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.9 - avg_words_per_second: 4113.1 - ETA: >2024-05-25 23:59:48 +2024-05-25 22:35:17 (UTC) - 0:48:37 - train - INFO - step: 000182 - done (%): 36.4 - loss: 1.233 - lr: 4.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.6 - avg_words_per_second: 4118.9 - ETA: >2024-05-25 23:59:37 +2024-05-25 22:35:29 (UTC) - 0:48:49 - train - INFO - step: 000183 - done (%): 36.6 - loss: 1.605 - lr: 4.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5521.8 - avg_words_per_second: 4124.6 - ETA: >2024-05-25 23:59:26 +2024-05-25 22:35:41 (UTC) - 0:49:01 - train - INFO - step: 000184 - done (%): 36.8 - loss: 1.260 - lr: 4.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.1 - avg_words_per_second: 4130.3 - ETA: >2024-05-25 23:59:15 +2024-05-25 22:35:53 (UTC) - 0:49:12 - train - INFO - step: 000185 - done (%): 37.0 - loss: 1.598 - lr: 4.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.9 - avg_words_per_second: 4136.0 - ETA: >2024-05-25 23:59:04 +2024-05-25 22:36:05 (UTC) - 0:49:24 - train - INFO - step: 000186 - done (%): 37.2 - loss: 1.588 - lr: 4.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5546.0 - avg_words_per_second: 4141.7 - ETA: >2024-05-25 23:58:53 +2024-05-25 22:36:17 (UTC) - 0:49:36 - train - INFO - step: 000187 - done (%): 37.4 - loss: 1.638 - lr: 4.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.3 - avg_words_per_second: 4147.3 - ETA: >2024-05-25 23:58:43 +2024-05-25 22:36:28 (UTC) - 0:49:48 - train - INFO - step: 000188 - done (%): 37.6 - loss: 1.880 - lr: 4.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5523.7 - avg_words_per_second: 4152.8 - ETA: >2024-05-25 23:58:32 +2024-05-25 22:36:40 (UTC) - 0:50:00 - train - INFO - step: 000189 - done (%): 37.8 - loss: 1.373 - lr: 4.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.0 - avg_words_per_second: 4158.3 - ETA: >2024-05-25 23:58:22 +2024-05-25 22:36:52 (UTC) - 0:50:12 - train - INFO - step: 000190 - done (%): 38.0 - loss: 1.554 - lr: 4.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.8 - avg_words_per_second: 4163.7 - ETA: >2024-05-25 23:58:11 +2024-05-25 22:37:04 (UTC) - 0:50:23 - train - INFO - step: 000191 - done (%): 38.2 - loss: 1.684 - lr: 4.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.4 - avg_words_per_second: 4169.1 - ETA: >2024-05-25 23:58:01 +2024-05-25 22:37:16 (UTC) - 0:50:35 - train - INFO - step: 000192 - done (%): 38.4 - loss: 1.644 - lr: 4.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.8 - avg_words_per_second: 4174.5 - ETA: >2024-05-25 23:57:51 +2024-05-25 22:37:28 (UTC) - 0:50:47 - train - INFO - step: 000193 - done (%): 38.6 - loss: 1.573 - lr: 4.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.5 - avg_words_per_second: 4179.8 - ETA: >2024-05-25 23:57:41 +2024-05-25 22:37:39 (UTC) - 0:50:59 - train - INFO - step: 000194 - done (%): 38.8 - loss: 1.588 - lr: 4.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.8 - avg_words_per_second: 4185.1 - ETA: >2024-05-25 23:57:31 +2024-05-25 22:37:51 (UTC) - 0:51:11 - train - INFO - step: 000195 - done (%): 39.0 - loss: 1.573 - lr: 4.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.2 - avg_words_per_second: 4190.3 - ETA: >2024-05-25 23:57:21 +2024-05-25 22:38:03 (UTC) - 0:51:23 - train - INFO - step: 000196 - done (%): 39.2 - loss: 1.380 - lr: 4.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.2 - avg_words_per_second: 4195.6 - ETA: >2024-05-25 23:57:12 +2024-05-25 22:38:15 (UTC) - 0:51:34 - train - INFO - step: 000197 - done (%): 39.4 - loss: 1.618 - lr: 4.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.6 - avg_words_per_second: 4200.7 - ETA: >2024-05-25 23:57:02 +2024-05-25 22:38:27 (UTC) - 0:51:46 - train - INFO - step: 000198 - done (%): 39.6 - loss: 1.450 - lr: 4.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5515.1 - avg_words_per_second: 4205.8 - ETA: >2024-05-25 23:56:53 +2024-05-25 22:38:39 (UTC) - 0:51:58 - train - INFO - step: 000199 - done (%): 39.8 - loss: 1.694 - lr: 4.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.1 - avg_words_per_second: 4210.9 - ETA: >2024-05-25 23:56:43 +2024-05-25 22:38:51 (UTC) - 0:52:10 - train - INFO - step: 000200 - done (%): 40.0 - loss: 1.470 - lr: 4.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.1 - avg_words_per_second: 4215.9 - ETA: >2024-05-25 23:56:34 +2024-05-25 22:38:51 (UTC) - 0:52:10 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runseed5/checkpoints/checkpoint_000200/consolidated using tmp name: tmp.consolidated +2024-05-25 22:39:05 (UTC) - 0:52:24 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runseed5/checkpoints/checkpoint_000200/consolidated for step: 200 +2024-05-25 22:39:05 (UTC) - 0:52:24 - checkpointing - INFO - Done deleting checkpoints +2024-05-25 22:39:05 (UTC) - 0:52:24 - checkpointing - INFO - Done! +2024-05-25 22:39:17 (UTC) - 0:52:36 - train - INFO - step: 000201 - done (%): 40.2 - loss: 1.370 - lr: 4.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5595.4 - avg_words_per_second: 4221.1 - ETA: >2024-05-25 23:56:39 +2024-05-25 22:39:28 (UTC) - 0:52:48 - train - INFO - step: 000202 - done (%): 40.4 - loss: 1.297 - lr: 4.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5561.9 - avg_words_per_second: 4226.1 - ETA: >2024-05-25 23:56:30 +2024-05-25 22:39:40 (UTC) - 0:53:00 - train - INFO - step: 000203 - done (%): 40.6 - loss: 1.427 - lr: 4.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.3 - avg_words_per_second: 4231.1 - ETA: >2024-05-25 23:56:20 +2024-05-25 22:39:52 (UTC) - 0:53:12 - train - INFO - step: 000204 - done (%): 40.8 - loss: 1.444 - lr: 4.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.5 - avg_words_per_second: 4236.0 - ETA: >2024-05-25 23:56:12 +2024-05-25 22:40:04 (UTC) - 0:53:23 - train - INFO - step: 000205 - done (%): 41.0 - loss: 1.351 - lr: 4.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.7 - avg_words_per_second: 4240.8 - ETA: >2024-05-25 23:56:03 +2024-05-25 22:40:16 (UTC) - 0:53:35 - train - INFO - step: 000206 - done (%): 41.2 - loss: 1.551 - lr: 4.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.6 - avg_words_per_second: 4245.7 - ETA: >2024-05-25 23:55:54 +2024-05-25 22:40:28 (UTC) - 0:53:47 - train - INFO - step: 000207 - done (%): 41.4 - loss: 1.254 - lr: 4.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.1 - avg_words_per_second: 4250.4 - ETA: >2024-05-25 23:55:45 +2024-05-25 22:40:39 (UTC) - 0:53:59 - train - INFO - step: 000208 - done (%): 41.6 - loss: 1.583 - lr: 4.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.0 - avg_words_per_second: 4255.2 - ETA: >2024-05-25 23:55:37 +2024-05-25 22:40:51 (UTC) - 0:54:11 - train - INFO - step: 000209 - done (%): 41.8 - loss: 1.622 - lr: 4.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.2 - avg_words_per_second: 4259.9 - ETA: >2024-05-25 23:55:28 +2024-05-25 22:41:03 (UTC) - 0:54:23 - train - INFO - step: 000210 - done (%): 42.0 - loss: 1.504 - lr: 4.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.7 - avg_words_per_second: 4264.5 - ETA: >2024-05-25 23:55:20 +2024-05-25 22:41:15 (UTC) - 0:54:34 - train - INFO - step: 000211 - done (%): 42.2 - loss: 1.620 - lr: 4.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.3 - avg_words_per_second: 4269.2 - ETA: >2024-05-25 23:55:11 +2024-05-25 22:41:27 (UTC) - 0:54:46 - train - INFO - step: 000212 - done (%): 42.4 - loss: 1.549 - lr: 4.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.9 - avg_words_per_second: 4273.8 - ETA: >2024-05-25 23:55:03 +2024-05-25 22:41:39 (UTC) - 0:54:58 - train - INFO - step: 000213 - done (%): 42.6 - loss: 1.008 - lr: 4.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.0 - avg_words_per_second: 4278.3 - ETA: >2024-05-25 23:54:55 +2024-05-25 22:41:51 (UTC) - 0:55:10 - train - INFO - step: 000214 - done (%): 42.8 - loss: 1.178 - lr: 3.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.8 - avg_words_per_second: 4282.9 - ETA: >2024-05-25 23:54:47 +2024-05-25 22:42:02 (UTC) - 0:55:22 - train - INFO - step: 000215 - done (%): 43.0 - loss: 1.264 - lr: 3.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.6 - avg_words_per_second: 4287.3 - ETA: >2024-05-25 23:54:39 +2024-05-25 22:42:14 (UTC) - 0:55:34 - train - INFO - step: 000216 - done (%): 43.2 - loss: 1.416 - lr: 3.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.4 - avg_words_per_second: 4291.8 - ETA: >2024-05-25 23:54:31 +2024-05-25 22:42:26 (UTC) - 0:55:46 - train - INFO - step: 000217 - done (%): 43.4 - loss: 1.051 - lr: 3.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.4 - avg_words_per_second: 4296.3 - ETA: >2024-05-25 23:54:23 +2024-05-25 22:42:38 (UTC) - 0:55:57 - train - INFO - step: 000218 - done (%): 43.6 - loss: 1.094 - lr: 3.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5549.0 - avg_words_per_second: 4300.7 - ETA: >2024-05-25 23:54:15 +2024-05-25 22:42:50 (UTC) - 0:56:09 - train - INFO - step: 000219 - done (%): 43.8 - loss: 1.476 - lr: 3.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.6 - avg_words_per_second: 4305.1 - ETA: >2024-05-25 23:54:07 +2024-05-25 22:43:02 (UTC) - 0:56:21 - train - INFO - step: 000220 - done (%): 44.0 - loss: 1.279 - lr: 3.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.8 - avg_words_per_second: 4309.5 - ETA: >2024-05-25 23:54:00 +2024-05-25 22:43:13 (UTC) - 0:56:33 - train - INFO - step: 000221 - done (%): 44.2 - loss: 1.369 - lr: 3.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.8 - avg_words_per_second: 4313.8 - ETA: >2024-05-25 23:53:52 +2024-05-25 22:43:25 (UTC) - 0:56:45 - train - INFO - step: 000222 - done (%): 44.4 - loss: 1.681 - lr: 3.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.8 - avg_words_per_second: 4318.1 - ETA: >2024-05-25 23:53:44 +2024-05-25 22:43:37 (UTC) - 0:56:57 - train - INFO - step: 000223 - done (%): 44.6 - loss: 1.636 - lr: 3.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.4 - avg_words_per_second: 4322.3 - ETA: >2024-05-25 23:53:37 +2024-05-25 22:43:49 (UTC) - 0:57:08 - train - INFO - step: 000224 - done (%): 44.8 - loss: 1.244 - lr: 3.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.7 - avg_words_per_second: 4326.6 - ETA: >2024-05-25 23:53:30 +2024-05-25 22:44:01 (UTC) - 0:57:20 - train - INFO - step: 000225 - done (%): 45.0 - loss: 1.737 - lr: 3.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.7 - avg_words_per_second: 4330.8 - ETA: >2024-05-25 23:53:22 +2024-05-25 22:44:13 (UTC) - 0:57:32 - train - INFO - step: 000226 - done (%): 45.2 - loss: 1.352 - lr: 3.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.5 - avg_words_per_second: 4334.9 - ETA: >2024-05-25 23:53:15 +2024-05-25 22:44:24 (UTC) - 0:57:44 - train - INFO - step: 000227 - done (%): 45.4 - loss: 1.543 - lr: 3.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.9 - avg_words_per_second: 4339.1 - ETA: >2024-05-25 23:53:08 +2024-05-25 22:44:49 (UTC) - 0:58:09 - train - INFO - step: 000228 - done (%): 45.6 - loss: 1.417 - lr: 3.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 2669.9 - avg_words_per_second: 4327.2 - ETA: >2024-05-25 23:53:28 +2024-05-25 22:45:01 (UTC) - 0:58:20 - train - INFO - step: 000229 - done (%): 45.8 - loss: 1.203 - lr: 3.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5547.6 - avg_words_per_second: 4331.4 - ETA: >2024-05-25 23:53:21 +2024-05-25 22:45:13 (UTC) - 0:58:32 - train - INFO - step: 000230 - done (%): 46.0 - loss: 1.519 - lr: 3.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.0 - avg_words_per_second: 4335.5 - ETA: >2024-05-25 23:53:14 +2024-05-25 22:45:24 (UTC) - 0:58:44 - train - INFO - step: 000231 - done (%): 46.2 - loss: 1.555 - lr: 3.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.5 - avg_words_per_second: 4339.6 - ETA: >2024-05-25 23:53:07 +2024-05-25 22:45:36 (UTC) - 0:58:56 - train - INFO - step: 000232 - done (%): 46.4 - loss: 1.334 - lr: 3.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.7 - avg_words_per_second: 4343.6 - ETA: >2024-05-25 23:53:00 +2024-05-25 22:45:48 (UTC) - 0:59:08 - train - INFO - step: 000233 - done (%): 46.6 - loss: 1.727 - lr: 3.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.8 - avg_words_per_second: 4347.6 - ETA: >2024-05-25 23:52:53 +2024-05-25 22:46:00 (UTC) - 0:59:20 - train - INFO - step: 000234 - done (%): 46.8 - loss: 1.612 - lr: 3.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.3 - avg_words_per_second: 4351.6 - ETA: >2024-05-25 23:52:46 +2024-05-25 22:46:12 (UTC) - 0:59:31 - train - INFO - step: 000235 - done (%): 47.0 - loss: 1.334 - lr: 3.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.5 - avg_words_per_second: 4355.6 - ETA: >2024-05-25 23:52:39 +2024-05-25 22:46:24 (UTC) - 0:59:43 - train - INFO - step: 000236 - done (%): 47.2 - loss: 1.165 - lr: 3.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.3 - avg_words_per_second: 4359.5 - ETA: >2024-05-25 23:52:32 +2024-05-25 22:46:36 (UTC) - 0:59:55 - train - INFO - step: 000237 - done (%): 47.4 - loss: 1.778 - lr: 3.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5514.8 - avg_words_per_second: 4363.3 - ETA: >2024-05-25 23:52:26 +2024-05-25 22:46:47 (UTC) - 1:00:07 - train - INFO - step: 000238 - done (%): 47.6 - loss: 1.407 - lr: 3.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.4 - avg_words_per_second: 4367.2 - ETA: >2024-05-25 23:52:19 +2024-05-25 22:46:59 (UTC) - 1:00:19 - train - INFO - step: 000239 - done (%): 47.8 - loss: 1.241 - lr: 3.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.3 - avg_words_per_second: 4371.1 - ETA: >2024-05-25 23:52:13 +2024-05-25 22:47:11 (UTC) - 1:00:31 - train - INFO - step: 000240 - done (%): 48.0 - loss: 1.413 - lr: 3.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.9 - avg_words_per_second: 4374.9 - ETA: >2024-05-25 23:52:06 +2024-05-25 22:47:23 (UTC) - 1:00:43 - train - INFO - step: 000241 - done (%): 48.2 - loss: 1.469 - lr: 3.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.7 - avg_words_per_second: 4378.7 - ETA: >2024-05-25 23:52:00 +2024-05-25 22:47:35 (UTC) - 1:00:54 - train - INFO - step: 000242 - done (%): 48.4 - loss: 1.335 - lr: 3.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.3 - avg_words_per_second: 4382.5 - ETA: >2024-05-25 23:51:53 +2024-05-25 22:47:47 (UTC) - 1:01:06 - train - INFO - step: 000243 - done (%): 48.6 - loss: 1.268 - lr: 3.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5519.5 - avg_words_per_second: 4386.2 - ETA: >2024-05-25 23:51:47 +2024-05-25 22:47:59 (UTC) - 1:01:18 - train - INFO - step: 000244 - done (%): 48.8 - loss: 1.309 - lr: 3.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.9 - avg_words_per_second: 4389.9 - ETA: >2024-05-25 23:51:40 +2024-05-25 22:48:10 (UTC) - 1:01:30 - train - INFO - step: 000245 - done (%): 49.0 - loss: 1.346 - lr: 3.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.6 - avg_words_per_second: 4393.6 - ETA: >2024-05-25 23:51:34 +2024-05-25 22:48:22 (UTC) - 1:01:42 - train - INFO - step: 000246 - done (%): 49.2 - loss: 1.692 - lr: 3.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.3 - avg_words_per_second: 4397.3 - ETA: >2024-05-25 23:51:28 +2024-05-25 22:48:34 (UTC) - 1:01:54 - train - INFO - step: 000247 - done (%): 49.4 - loss: 1.520 - lr: 3.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5521.8 - avg_words_per_second: 4400.9 - ETA: >2024-05-25 23:51:22 +2024-05-25 22:48:46 (UTC) - 1:02:05 - train - INFO - step: 000248 - done (%): 49.6 - loss: 1.643 - lr: 3.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.2 - avg_words_per_second: 4404.6 - ETA: >2024-05-25 23:51:15 +2024-05-25 22:48:58 (UTC) - 1:02:17 - train - INFO - step: 000249 - done (%): 49.8 - loss: 1.054 - lr: 3.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.3 - avg_words_per_second: 4408.2 - ETA: >2024-05-25 23:51:09 +2024-05-25 22:49:10 (UTC) - 1:02:29 - train - INFO - step: 000250 - done (%): 50.0 - loss: 1.596 - lr: 3.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.0 - avg_words_per_second: 4411.8 - ETA: >2024-05-25 23:51:03 +2024-05-25 22:49:22 (UTC) - 1:02:41 - train - INFO - step: 000251 - done (%): 50.2 - loss: 1.676 - lr: 3.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.3 - avg_words_per_second: 4415.3 - ETA: >2024-05-25 23:50:57 +2024-05-25 22:49:33 (UTC) - 1:02:53 - train - INFO - step: 000252 - done (%): 50.4 - loss: 1.171 - lr: 3.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.2 - avg_words_per_second: 4418.9 - ETA: >2024-05-25 23:50:51 +2024-05-25 22:49:45 (UTC) - 1:03:05 - train - INFO - step: 000253 - done (%): 50.6 - loss: 1.225 - lr: 3.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.0 - avg_words_per_second: 4422.4 - ETA: >2024-05-25 23:50:45 +2024-05-25 22:49:57 (UTC) - 1:03:17 - train - INFO - step: 000254 - done (%): 50.8 - loss: 1.532 - lr: 3.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.7 - avg_words_per_second: 4425.9 - ETA: >2024-05-25 23:50:40 +2024-05-25 22:50:09 (UTC) - 1:03:28 - train - INFO - step: 000255 - done (%): 51.0 - loss: 1.554 - lr: 3.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.8 - avg_words_per_second: 4429.4 - ETA: >2024-05-25 23:50:34 +2024-05-25 22:50:21 (UTC) - 1:03:40 - train - INFO - step: 000256 - done (%): 51.2 - loss: 1.494 - lr: 3.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5518.6 - avg_words_per_second: 4432.8 - ETA: >2024-05-25 23:50:28 +2024-05-25 22:50:33 (UTC) - 1:03:52 - train - INFO - step: 000257 - done (%): 51.4 - loss: 1.649 - lr: 3.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.9 - avg_words_per_second: 4436.2 - ETA: >2024-05-25 23:50:22 +2024-05-25 22:50:44 (UTC) - 1:04:04 - train - INFO - step: 000258 - done (%): 51.6 - loss: 1.218 - lr: 3.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.0 - avg_words_per_second: 4439.6 - ETA: >2024-05-25 23:50:17 +2024-05-25 22:50:56 (UTC) - 1:04:16 - train - INFO - step: 000259 - done (%): 51.8 - loss: 1.344 - lr: 3.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.4 - avg_words_per_second: 4443.0 - ETA: >2024-05-25 23:50:11 +2024-05-25 22:51:08 (UTC) - 1:04:28 - train - INFO - step: 000260 - done (%): 52.0 - loss: 1.194 - lr: 3.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.5 - avg_words_per_second: 4446.4 - ETA: >2024-05-25 23:50:05 +2024-05-25 22:51:20 (UTC) - 1:04:39 - train - INFO - step: 000261 - done (%): 52.2 - loss: 1.567 - lr: 3.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.2 - avg_words_per_second: 4449.8 - ETA: >2024-05-25 23:50:00 +2024-05-25 22:51:32 (UTC) - 1:04:51 - train - INFO - step: 000262 - done (%): 52.4 - loss: 1.233 - lr: 3.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5520.5 - avg_words_per_second: 4453.1 - ETA: >2024-05-25 23:49:55 +2024-05-25 22:51:44 (UTC) - 1:05:03 - train - INFO - step: 000263 - done (%): 52.6 - loss: 1.752 - lr: 3.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.1 - avg_words_per_second: 4456.4 - ETA: >2024-05-25 23:49:49 +2024-05-25 22:51:56 (UTC) - 1:05:15 - train - INFO - step: 000264 - done (%): 52.8 - loss: 1.538 - lr: 3.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.9 - avg_words_per_second: 4459.6 - ETA: >2024-05-25 23:49:44 +2024-05-25 22:52:07 (UTC) - 1:05:27 - train - INFO - step: 000265 - done (%): 53.0 - loss: 1.257 - lr: 3.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.6 - avg_words_per_second: 4462.9 - ETA: >2024-05-25 23:49:38 +2024-05-25 22:52:19 (UTC) - 1:05:39 - train - INFO - step: 000266 - done (%): 53.2 - loss: 1.176 - lr: 2.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5506.6 - avg_words_per_second: 4466.1 - ETA: >2024-05-25 23:49:33 +2024-05-25 22:52:31 (UTC) - 1:05:51 - train - INFO - step: 000267 - done (%): 53.4 - loss: 1.818 - lr: 2.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.1 - avg_words_per_second: 4469.3 - ETA: >2024-05-25 23:49:28 +2024-05-25 22:52:43 (UTC) - 1:06:03 - train - INFO - step: 000268 - done (%): 53.6 - loss: 1.501 - lr: 2.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5508.7 - avg_words_per_second: 4472.4 - ETA: >2024-05-25 23:49:23 +2024-05-25 22:52:55 (UTC) - 1:06:14 - train - INFO - step: 000269 - done (%): 53.8 - loss: 1.369 - lr: 2.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5518.6 - avg_words_per_second: 4475.6 - ETA: >2024-05-25 23:49:17 +2024-05-25 22:53:07 (UTC) - 1:06:26 - train - INFO - step: 000270 - done (%): 54.0 - loss: 1.351 - lr: 2.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5519.4 - avg_words_per_second: 4478.7 - ETA: >2024-05-25 23:49:12 +2024-05-25 22:53:19 (UTC) - 1:06:38 - train - INFO - step: 000271 - done (%): 54.2 - loss: 1.298 - lr: 2.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5517.0 - avg_words_per_second: 4481.8 - ETA: >2024-05-25 23:49:07 +2024-05-25 22:53:31 (UTC) - 1:06:50 - train - INFO - step: 000272 - done (%): 54.4 - loss: 1.147 - lr: 2.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.4 - avg_words_per_second: 4485.0 - ETA: >2024-05-25 23:49:02 +2024-05-25 22:53:42 (UTC) - 1:07:02 - train - INFO - step: 000273 - done (%): 54.6 - loss: 1.430 - lr: 2.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.8 - avg_words_per_second: 4488.1 - ETA: >2024-05-25 23:48:57 +2024-05-25 22:53:54 (UTC) - 1:07:14 - train - INFO - step: 000274 - done (%): 54.8 - loss: 1.398 - lr: 2.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.4 - avg_words_per_second: 4491.2 - ETA: >2024-05-25 23:48:52 +2024-05-25 22:54:06 (UTC) - 1:07:26 - train - INFO - step: 000275 - done (%): 55.0 - loss: 1.497 - lr: 2.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5516.2 - avg_words_per_second: 4494.2 - ETA: >2024-05-25 23:48:47 +2024-05-25 22:54:18 (UTC) - 1:07:38 - train - INFO - step: 000276 - done (%): 55.2 - loss: 1.304 - lr: 2.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5521.6 - avg_words_per_second: 4497.3 - ETA: >2024-05-25 23:48:42 +2024-05-25 22:54:30 (UTC) - 1:07:49 - train - INFO - step: 000277 - done (%): 55.4 - loss: 1.488 - lr: 2.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.1 - avg_words_per_second: 4500.3 - ETA: >2024-05-25 23:48:37 +2024-05-25 22:54:42 (UTC) - 1:08:01 - train - INFO - step: 000278 - done (%): 55.6 - loss: 1.497 - lr: 2.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.6 - avg_words_per_second: 4503.3 - ETA: >2024-05-25 23:48:32 +2024-05-25 22:54:54 (UTC) - 1:08:13 - train - INFO - step: 000279 - done (%): 55.8 - loss: 1.898 - lr: 2.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.4 - avg_words_per_second: 4506.3 - ETA: >2024-05-25 23:48:28 +2024-05-25 22:55:05 (UTC) - 1:08:25 - train - INFO - step: 000280 - done (%): 56.0 - loss: 1.474 - lr: 2.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.7 - avg_words_per_second: 4509.3 - ETA: >2024-05-25 23:48:23 +2024-05-25 22:55:17 (UTC) - 1:08:37 - train - INFO - step: 000281 - done (%): 56.2 - loss: 1.401 - lr: 2.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.0 - avg_words_per_second: 4512.2 - ETA: >2024-05-25 23:48:18 +2024-05-25 22:55:29 (UTC) - 1:08:49 - train - INFO - step: 000282 - done (%): 56.4 - loss: 1.512 - lr: 2.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5514.9 - avg_words_per_second: 4515.1 - ETA: >2024-05-25 23:48:13 +2024-05-25 22:55:41 (UTC) - 1:09:01 - train - INFO - step: 000283 - done (%): 56.6 - loss: 1.403 - lr: 2.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.5 - avg_words_per_second: 4518.1 - ETA: >2024-05-25 23:48:09 +2024-05-25 22:55:53 (UTC) - 1:09:12 - train - INFO - step: 000284 - done (%): 56.8 - loss: 1.500 - lr: 2.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.7 - avg_words_per_second: 4521.0 - ETA: >2024-05-25 23:48:04 +2024-05-25 22:56:05 (UTC) - 1:09:24 - train - INFO - step: 000285 - done (%): 57.0 - loss: 1.353 - lr: 2.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.2 - avg_words_per_second: 4523.9 - ETA: >2024-05-25 23:47:59 +2024-05-25 22:56:17 (UTC) - 1:09:36 - train - INFO - step: 000286 - done (%): 57.2 - loss: 1.132 - lr: 2.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.9 - avg_words_per_second: 4526.8 - ETA: >2024-05-25 23:47:55 +2024-05-25 22:56:28 (UTC) - 1:09:48 - train - INFO - step: 000287 - done (%): 57.4 - loss: 1.487 - lr: 2.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.0 - avg_words_per_second: 4529.7 - ETA: >2024-05-25 23:47:50 +2024-05-25 22:56:40 (UTC) - 1:10:00 - train - INFO - step: 000288 - done (%): 57.6 - loss: 1.560 - lr: 2.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.8 - avg_words_per_second: 4532.5 - ETA: >2024-05-25 23:47:46 +2024-05-25 22:56:52 (UTC) - 1:10:12 - train - INFO - step: 000289 - done (%): 57.8 - loss: 1.445 - lr: 2.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.3 - avg_words_per_second: 4535.4 - ETA: >2024-05-25 23:47:41 +2024-05-25 22:57:04 (UTC) - 1:10:23 - train - INFO - step: 000290 - done (%): 58.0 - loss: 1.385 - lr: 2.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.5 - avg_words_per_second: 4538.2 - ETA: >2024-05-25 23:47:37 +2024-05-25 22:57:16 (UTC) - 1:10:35 - train - INFO - step: 000291 - done (%): 58.2 - loss: 1.879 - lr: 2.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.6 - avg_words_per_second: 4541.0 - ETA: >2024-05-25 23:47:32 +2024-05-25 22:57:28 (UTC) - 1:10:47 - train - INFO - step: 000292 - done (%): 58.4 - loss: 1.462 - lr: 2.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5512.9 - avg_words_per_second: 4543.7 - ETA: >2024-05-25 23:47:28 +2024-05-25 22:57:40 (UTC) - 1:10:59 - train - INFO - step: 000293 - done (%): 58.6 - loss: 1.581 - lr: 2.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.9 - avg_words_per_second: 4546.5 - ETA: >2024-05-25 23:47:23 +2024-05-25 22:57:51 (UTC) - 1:11:11 - train - INFO - step: 000294 - done (%): 58.8 - loss: 1.524 - lr: 2.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.6 - avg_words_per_second: 4549.2 - ETA: >2024-05-25 23:47:19 +2024-05-25 22:58:03 (UTC) - 1:11:23 - train - INFO - step: 000295 - done (%): 59.0 - loss: 1.449 - lr: 2.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.5 - avg_words_per_second: 4552.0 - ETA: >2024-05-25 23:47:15 +2024-05-25 22:58:15 (UTC) - 1:11:35 - train - INFO - step: 000296 - done (%): 59.2 - loss: 1.366 - lr: 2.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.3 - avg_words_per_second: 4554.7 - ETA: >2024-05-25 23:47:10 +2024-05-25 22:58:27 (UTC) - 1:11:46 - train - INFO - step: 000297 - done (%): 59.4 - loss: 1.130 - lr: 2.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5518.6 - avg_words_per_second: 4557.4 - ETA: >2024-05-25 23:47:06 +2024-05-25 22:58:39 (UTC) - 1:11:58 - train - INFO - step: 000298 - done (%): 59.6 - loss: 1.586 - lr: 2.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.3 - avg_words_per_second: 4560.1 - ETA: >2024-05-25 23:47:02 +2024-05-25 22:58:51 (UTC) - 1:12:10 - train - INFO - step: 000299 - done (%): 59.8 - loss: 1.351 - lr: 2.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5517.8 - avg_words_per_second: 4562.7 - ETA: >2024-05-25 23:46:58 +2024-05-25 22:59:03 (UTC) - 1:12:22 - train - INFO - step: 000300 - done (%): 60.0 - loss: 1.279 - lr: 2.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.4 - avg_words_per_second: 4565.4 - ETA: >2024-05-25 23:46:54 +2024-05-25 22:59:03 (UTC) - 1:12:22 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runseed5/checkpoints/checkpoint_000300/consolidated using tmp name: tmp.consolidated +2024-05-25 22:59:17 (UTC) - 1:12:36 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runseed5/checkpoints/checkpoint_000300/consolidated for step: 300 +2024-05-25 22:59:17 (UTC) - 1:12:36 - checkpointing - INFO - Done deleting checkpoints +2024-05-25 22:59:17 (UTC) - 1:12:36 - checkpointing - INFO - Done! +2024-05-25 22:59:29 (UTC) - 1:12:48 - train - INFO - step: 000301 - done (%): 60.2 - loss: 1.616 - lr: 2.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5596.1 - avg_words_per_second: 4568.2 - ETA: >2024-05-25 23:47:03 +2024-05-25 22:59:40 (UTC) - 1:13:00 - train - INFO - step: 000302 - done (%): 60.4 - loss: 1.353 - lr: 2.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5549.4 - avg_words_per_second: 4570.9 - ETA: >2024-05-25 23:46:59 +2024-05-25 22:59:52 (UTC) - 1:13:12 - train - INFO - step: 000303 - done (%): 60.6 - loss: 1.306 - lr: 2.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.7 - avg_words_per_second: 4573.5 - ETA: >2024-05-25 23:46:55 +2024-05-25 23:00:04 (UTC) - 1:13:24 - train - INFO - step: 000304 - done (%): 60.8 - loss: 1.474 - lr: 2.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.7 - avg_words_per_second: 4576.1 - ETA: >2024-05-25 23:46:51 +2024-05-25 23:00:16 (UTC) - 1:13:35 - train - INFO - step: 000305 - done (%): 61.0 - loss: 1.767 - lr: 2.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.9 - avg_words_per_second: 4578.7 - ETA: >2024-05-25 23:46:47 +2024-05-25 23:00:28 (UTC) - 1:13:47 - train - INFO - step: 000306 - done (%): 61.2 - loss: 1.460 - lr: 2.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.6 - avg_words_per_second: 4581.3 - ETA: >2024-05-25 23:46:43 +2024-05-25 23:00:40 (UTC) - 1:13:59 - train - INFO - step: 000307 - done (%): 61.4 - loss: 1.585 - lr: 2.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.8 - avg_words_per_second: 4583.9 - ETA: >2024-05-25 23:46:39 +2024-05-25 23:00:51 (UTC) - 1:14:11 - train - INFO - step: 000308 - done (%): 61.6 - loss: 1.692 - lr: 2.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.5 - avg_words_per_second: 4586.4 - ETA: >2024-05-25 23:46:35 +2024-05-25 23:01:03 (UTC) - 1:14:23 - train - INFO - step: 000309 - done (%): 61.8 - loss: 1.319 - lr: 2.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.9 - avg_words_per_second: 4589.0 - ETA: >2024-05-25 23:46:31 +2024-05-25 23:01:15 (UTC) - 1:14:35 - train - INFO - step: 000310 - done (%): 62.0 - loss: 1.571 - lr: 2.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5520.8 - avg_words_per_second: 4591.5 - ETA: >2024-05-25 23:46:27 +2024-05-25 23:01:27 (UTC) - 1:14:46 - train - INFO - step: 000311 - done (%): 62.2 - loss: 1.374 - lr: 2.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.5 - avg_words_per_second: 4594.0 - ETA: >2024-05-25 23:46:23 +2024-05-25 23:01:39 (UTC) - 1:14:58 - train - INFO - step: 000312 - done (%): 62.4 - loss: 1.531 - lr: 2.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.4 - avg_words_per_second: 4596.5 - ETA: >2024-05-25 23:46:19 +2024-05-25 23:01:51 (UTC) - 1:15:10 - train - INFO - step: 000313 - done (%): 62.6 - loss: 1.690 - lr: 2.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.0 - avg_words_per_second: 4599.0 - ETA: >2024-05-25 23:46:15 +2024-05-25 23:02:03 (UTC) - 1:15:22 - train - INFO - step: 000314 - done (%): 62.8 - loss: 1.492 - lr: 2.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.2 - avg_words_per_second: 4601.4 - ETA: >2024-05-25 23:46:12 +2024-05-25 23:02:14 (UTC) - 1:15:34 - train - INFO - step: 000315 - done (%): 63.0 - loss: 1.363 - lr: 2.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.6 - avg_words_per_second: 4603.9 - ETA: >2024-05-25 23:46:08 +2024-05-25 23:02:26 (UTC) - 1:15:46 - train - INFO - step: 000316 - done (%): 63.2 - loss: 1.536 - lr: 2.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.8 - avg_words_per_second: 4606.3 - ETA: >2024-05-25 23:46:04 +2024-05-25 23:02:38 (UTC) - 1:15:58 - train - INFO - step: 000317 - done (%): 63.4 - loss: 0.918 - lr: 1.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.0 - avg_words_per_second: 4608.8 - ETA: >2024-05-25 23:46:00 +2024-05-25 23:02:50 (UTC) - 1:16:09 - train - INFO - step: 000318 - done (%): 63.6 - loss: 1.602 - lr: 1.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.6 - avg_words_per_second: 4611.2 - ETA: >2024-05-25 23:45:57 +2024-05-25 23:03:02 (UTC) - 1:16:21 - train - INFO - step: 000319 - done (%): 63.8 - loss: 1.502 - lr: 1.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.3 - avg_words_per_second: 4613.6 - ETA: >2024-05-25 23:45:53 +2024-05-25 23:03:14 (UTC) - 1:16:33 - train - INFO - step: 000320 - done (%): 64.0 - loss: 1.174 - lr: 1.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.7 - avg_words_per_second: 4616.0 - ETA: >2024-05-25 23:45:49 +2024-05-25 23:03:25 (UTC) - 1:16:45 - train - INFO - step: 000321 - done (%): 64.2 - loss: 1.312 - lr: 1.9e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.1 - avg_words_per_second: 4618.4 - ETA: >2024-05-25 23:45:45 +2024-05-25 23:03:37 (UTC) - 1:16:57 - train - INFO - step: 000322 - done (%): 64.4 - loss: 1.556 - lr: 1.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.7 - avg_words_per_second: 4620.8 - ETA: >2024-05-25 23:45:42 +2024-05-25 23:03:49 (UTC) - 1:17:09 - train - INFO - step: 000323 - done (%): 64.6 - loss: 1.376 - lr: 1.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.6 - avg_words_per_second: 4623.1 - ETA: >2024-05-25 23:45:38 +2024-05-25 23:04:01 (UTC) - 1:17:20 - train - INFO - step: 000324 - done (%): 64.8 - loss: 1.338 - lr: 1.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.3 - avg_words_per_second: 4625.5 - ETA: >2024-05-25 23:45:35 +2024-05-25 23:04:13 (UTC) - 1:17:32 - train - INFO - step: 000325 - done (%): 65.0 - loss: 1.470 - lr: 1.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.8 - avg_words_per_second: 4627.8 - ETA: >2024-05-25 23:45:31 +2024-05-25 23:04:25 (UTC) - 1:17:44 - train - INFO - step: 000326 - done (%): 65.2 - loss: 1.063 - lr: 1.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.6 - avg_words_per_second: 4630.2 - ETA: >2024-05-25 23:45:27 +2024-05-25 23:04:36 (UTC) - 1:17:56 - train - INFO - step: 000327 - done (%): 65.4 - loss: 1.150 - lr: 1.8e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5545.6 - avg_words_per_second: 4632.5 - ETA: >2024-05-25 23:45:24 +2024-05-25 23:04:48 (UTC) - 1:18:08 - train - INFO - step: 000328 - done (%): 65.6 - loss: 1.332 - lr: 1.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.2 - avg_words_per_second: 4634.8 - ETA: >2024-05-25 23:45:20 +2024-05-25 23:05:00 (UTC) - 1:18:20 - train - INFO - step: 000329 - done (%): 65.8 - loss: 0.928 - lr: 1.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.8 - avg_words_per_second: 4637.1 - ETA: >2024-05-25 23:45:17 +2024-05-25 23:05:12 (UTC) - 1:18:31 - train - INFO - step: 000330 - done (%): 66.0 - loss: 1.566 - lr: 1.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.8 - avg_words_per_second: 4639.4 - ETA: >2024-05-25 23:45:13 +2024-05-25 23:05:24 (UTC) - 1:18:43 - train - INFO - step: 000331 - done (%): 66.2 - loss: 1.357 - lr: 1.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.9 - avg_words_per_second: 4641.6 - ETA: >2024-05-25 23:45:10 +2024-05-25 23:05:36 (UTC) - 1:18:55 - train - INFO - step: 000332 - done (%): 66.4 - loss: 1.501 - lr: 1.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5521.8 - avg_words_per_second: 4643.9 - ETA: >2024-05-25 23:45:07 +2024-05-25 23:05:48 (UTC) - 1:19:07 - train - INFO - step: 000333 - done (%): 66.6 - loss: 1.255 - lr: 1.7e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.4 - avg_words_per_second: 4646.1 - ETA: >2024-05-25 23:45:03 +2024-05-25 23:05:59 (UTC) - 1:19:19 - train - INFO - step: 000334 - done (%): 66.8 - loss: 1.473 - lr: 1.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.3 - avg_words_per_second: 4648.3 - ETA: >2024-05-25 23:45:00 +2024-05-25 23:06:11 (UTC) - 1:19:31 - train - INFO - step: 000335 - done (%): 67.0 - loss: 1.245 - lr: 1.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.6 - avg_words_per_second: 4650.6 - ETA: >2024-05-25 23:44:56 +2024-05-25 23:06:23 (UTC) - 1:19:43 - train - INFO - step: 000336 - done (%): 67.2 - loss: 1.144 - lr: 1.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.7 - avg_words_per_second: 4652.8 - ETA: >2024-05-25 23:44:53 +2024-05-25 23:06:35 (UTC) - 1:19:54 - train - INFO - step: 000337 - done (%): 67.4 - loss: 1.227 - lr: 1.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.2 - avg_words_per_second: 4655.0 - ETA: >2024-05-25 23:44:50 +2024-05-25 23:06:47 (UTC) - 1:20:06 - train - INFO - step: 000338 - done (%): 67.6 - loss: 1.098 - lr: 1.6e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.4 - avg_words_per_second: 4657.1 - ETA: >2024-05-25 23:44:46 +2024-05-25 23:06:59 (UTC) - 1:20:18 - train - INFO - step: 000339 - done (%): 67.8 - loss: 1.598 - lr: 1.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.5 - avg_words_per_second: 4659.3 - ETA: >2024-05-25 23:44:43 +2024-05-25 23:07:11 (UTC) - 1:20:30 - train - INFO - step: 000340 - done (%): 68.0 - loss: 1.365 - lr: 1.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.9 - avg_words_per_second: 4661.5 - ETA: >2024-05-25 23:44:40 +2024-05-25 23:07:22 (UTC) - 1:20:42 - train - INFO - step: 000341 - done (%): 68.2 - loss: 1.765 - lr: 1.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.1 - avg_words_per_second: 4663.6 - ETA: >2024-05-25 23:44:37 +2024-05-25 23:07:34 (UTC) - 1:20:54 - train - INFO - step: 000342 - done (%): 68.4 - loss: 1.611 - lr: 1.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.2 - avg_words_per_second: 4665.8 - ETA: >2024-05-25 23:44:33 +2024-05-25 23:07:46 (UTC) - 1:21:06 - train - INFO - step: 000343 - done (%): 68.6 - loss: 1.263 - lr: 1.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.9 - avg_words_per_second: 4667.9 - ETA: >2024-05-25 23:44:30 +2024-05-25 23:07:58 (UTC) - 1:21:17 - train - INFO - step: 000344 - done (%): 68.8 - loss: 1.222 - lr: 1.5e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.9 - avg_words_per_second: 4670.0 - ETA: >2024-05-25 23:44:27 +2024-05-25 23:08:10 (UTC) - 1:21:29 - train - INFO - step: 000345 - done (%): 69.0 - loss: 1.333 - lr: 1.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.8 - avg_words_per_second: 4672.2 - ETA: >2024-05-25 23:44:24 +2024-05-25 23:08:22 (UTC) - 1:21:41 - train - INFO - step: 000346 - done (%): 69.2 - loss: 1.656 - lr: 1.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.3 - avg_words_per_second: 4674.3 - ETA: >2024-05-25 23:44:21 +2024-05-25 23:08:33 (UTC) - 1:21:53 - train - INFO - step: 000347 - done (%): 69.4 - loss: 1.091 - lr: 1.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.0 - avg_words_per_second: 4676.3 - ETA: >2024-05-25 23:44:18 +2024-05-25 23:08:57 (UTC) - 1:22:17 - train - INFO - step: 000348 - done (%): 69.6 - loss: 1.215 - lr: 1.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 2773.9 - avg_words_per_second: 4667.2 - ETA: >2024-05-25 23:44:31 +2024-05-25 23:09:09 (UTC) - 1:22:28 - train - INFO - step: 000349 - done (%): 69.8 - loss: 1.466 - lr: 1.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5554.7 - avg_words_per_second: 4669.3 - ETA: >2024-05-25 23:44:28 +2024-05-25 23:09:21 (UTC) - 1:22:40 - train - INFO - step: 000350 - done (%): 70.0 - loss: 1.327 - lr: 1.4e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5523.4 - avg_words_per_second: 4671.4 - ETA: >2024-05-25 23:44:25 +2024-05-25 23:09:33 (UTC) - 1:22:52 - train - INFO - step: 000351 - done (%): 70.2 - loss: 1.249 - lr: 1.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.6 - avg_words_per_second: 4673.4 - ETA: >2024-05-25 23:44:22 +2024-05-25 23:09:44 (UTC) - 1:23:04 - train - INFO - step: 000352 - done (%): 70.4 - loss: 1.041 - lr: 1.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5523.7 - avg_words_per_second: 4675.5 - ETA: >2024-05-25 23:44:19 +2024-05-25 23:09:56 (UTC) - 1:23:16 - train - INFO - step: 000353 - done (%): 70.6 - loss: 1.243 - lr: 1.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.1 - avg_words_per_second: 4677.5 - ETA: >2024-05-25 23:44:16 +2024-05-25 23:10:08 (UTC) - 1:23:28 - train - INFO - step: 000354 - done (%): 70.8 - loss: 1.302 - lr: 1.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.8 - avg_words_per_second: 4679.6 - ETA: >2024-05-25 23:44:13 +2024-05-25 23:10:20 (UTC) - 1:23:39 - train - INFO - step: 000355 - done (%): 71.0 - loss: 1.125 - lr: 1.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.1 - avg_words_per_second: 4681.6 - ETA: >2024-05-25 23:44:10 +2024-05-25 23:10:32 (UTC) - 1:23:51 - train - INFO - step: 000356 - done (%): 71.2 - loss: 1.213 - lr: 1.3e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.4 - avg_words_per_second: 4683.7 - ETA: >2024-05-25 23:44:07 +2024-05-25 23:10:44 (UTC) - 1:24:03 - train - INFO - step: 000357 - done (%): 71.4 - loss: 1.164 - lr: 1.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.6 - avg_words_per_second: 4685.7 - ETA: >2024-05-25 23:44:04 +2024-05-25 23:10:55 (UTC) - 1:24:15 - train - INFO - step: 000358 - done (%): 71.6 - loss: 1.353 - lr: 1.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.0 - avg_words_per_second: 4687.7 - ETA: >2024-05-25 23:44:01 +2024-05-25 23:11:07 (UTC) - 1:24:27 - train - INFO - step: 000359 - done (%): 71.8 - loss: 1.558 - lr: 1.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5545.0 - avg_words_per_second: 4689.7 - ETA: >2024-05-25 23:43:58 +2024-05-25 23:11:19 (UTC) - 1:24:39 - train - INFO - step: 000360 - done (%): 72.0 - loss: 1.347 - lr: 1.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.5 - avg_words_per_second: 4691.7 - ETA: >2024-05-25 23:43:55 +2024-05-25 23:11:31 (UTC) - 1:24:50 - train - INFO - step: 000361 - done (%): 72.2 - loss: 1.318 - lr: 1.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.0 - avg_words_per_second: 4693.7 - ETA: >2024-05-25 23:43:52 +2024-05-25 23:11:43 (UTC) - 1:25:02 - train - INFO - step: 000362 - done (%): 72.4 - loss: 1.455 - lr: 1.2e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.9 - avg_words_per_second: 4695.6 - ETA: >2024-05-25 23:43:49 +2024-05-25 23:11:55 (UTC) - 1:25:14 - train - INFO - step: 000363 - done (%): 72.6 - loss: 1.327 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.1 - avg_words_per_second: 4697.6 - ETA: >2024-05-25 23:43:46 +2024-05-25 23:12:06 (UTC) - 1:25:26 - train - INFO - step: 000364 - done (%): 72.8 - loss: 1.119 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.7 - avg_words_per_second: 4699.5 - ETA: >2024-05-25 23:43:43 +2024-05-25 23:12:18 (UTC) - 1:25:38 - train - INFO - step: 000365 - done (%): 73.0 - loss: 1.480 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.2 - avg_words_per_second: 4701.5 - ETA: >2024-05-25 23:43:40 +2024-05-25 23:12:30 (UTC) - 1:25:50 - train - INFO - step: 000366 - done (%): 73.2 - loss: 1.575 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.4 - avg_words_per_second: 4703.4 - ETA: >2024-05-25 23:43:37 +2024-05-25 23:12:42 (UTC) - 1:26:02 - train - INFO - step: 000367 - done (%): 73.4 - loss: 1.028 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.0 - avg_words_per_second: 4705.4 - ETA: >2024-05-25 23:43:34 +2024-05-25 23:12:54 (UTC) - 1:26:13 - train - INFO - step: 000368 - done (%): 73.6 - loss: 1.233 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.7 - avg_words_per_second: 4707.3 - ETA: >2024-05-25 23:43:32 +2024-05-25 23:13:06 (UTC) - 1:26:25 - train - INFO - step: 000369 - done (%): 73.8 - loss: 1.436 - lr: 1.1e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.9 - avg_words_per_second: 4709.2 - ETA: >2024-05-25 23:43:29 +2024-05-25 23:13:17 (UTC) - 1:26:37 - train - INFO - step: 000370 - done (%): 74.0 - loss: 1.319 - lr: 1.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.4 - avg_words_per_second: 4711.1 - ETA: >2024-05-25 23:43:26 +2024-05-25 23:13:29 (UTC) - 1:26:49 - train - INFO - step: 000371 - done (%): 74.2 - loss: 1.388 - lr: 1.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5545.9 - avg_words_per_second: 4713.0 - ETA: >2024-05-25 23:43:23 +2024-05-25 23:13:41 (UTC) - 1:27:01 - train - INFO - step: 000372 - done (%): 74.4 - loss: 1.307 - lr: 1.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.8 - avg_words_per_second: 4714.9 - ETA: >2024-05-25 23:43:20 +2024-05-25 23:13:53 (UTC) - 1:27:13 - train - INFO - step: 000373 - done (%): 74.6 - loss: 1.504 - lr: 1.0e-05 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.1 - avg_words_per_second: 4716.8 - ETA: >2024-05-25 23:43:18 +2024-05-25 23:14:05 (UTC) - 1:27:24 - train - INFO - step: 000374 - done (%): 74.8 - loss: 1.137 - lr: 9.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.2 - avg_words_per_second: 4718.7 - ETA: >2024-05-25 23:43:15 +2024-05-25 23:14:17 (UTC) - 1:27:36 - train - INFO - step: 000375 - done (%): 75.0 - loss: 1.364 - lr: 9.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.1 - avg_words_per_second: 4720.5 - ETA: >2024-05-25 23:43:12 +2024-05-25 23:14:29 (UTC) - 1:27:48 - train - INFO - step: 000376 - done (%): 75.2 - loss: 1.640 - lr: 9.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.0 - avg_words_per_second: 4722.4 - ETA: >2024-05-25 23:43:09 +2024-05-25 23:14:40 (UTC) - 1:28:00 - train - INFO - step: 000377 - done (%): 75.4 - loss: 1.579 - lr: 9.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5525.9 - avg_words_per_second: 4724.2 - ETA: >2024-05-25 23:43:07 +2024-05-25 23:14:52 (UTC) - 1:28:12 - train - INFO - step: 000378 - done (%): 75.6 - loss: 1.289 - lr: 9.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.4 - avg_words_per_second: 4726.0 - ETA: >2024-05-25 23:43:04 +2024-05-25 23:15:04 (UTC) - 1:28:24 - train - INFO - step: 000379 - done (%): 75.8 - loss: 1.053 - lr: 9.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.3 - avg_words_per_second: 4727.8 - ETA: >2024-05-25 23:43:01 +2024-05-25 23:15:16 (UTC) - 1:28:35 - train - INFO - step: 000380 - done (%): 76.0 - loss: 1.310 - lr: 9.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.7 - avg_words_per_second: 4729.7 - ETA: >2024-05-25 23:42:59 +2024-05-25 23:15:28 (UTC) - 1:28:47 - train - INFO - step: 000381 - done (%): 76.2 - loss: 0.957 - lr: 8.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5503.4 - avg_words_per_second: 4731.4 - ETA: >2024-05-25 23:42:56 +2024-05-25 23:15:40 (UTC) - 1:28:59 - train - INFO - step: 000382 - done (%): 76.4 - loss: 1.262 - lr: 8.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.8 - avg_words_per_second: 4733.2 - ETA: >2024-05-25 23:42:53 +2024-05-25 23:15:51 (UTC) - 1:29:11 - train - INFO - step: 000383 - done (%): 76.6 - loss: 1.507 - lr: 8.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.7 - avg_words_per_second: 4735.0 - ETA: >2024-05-25 23:42:51 +2024-05-25 23:16:03 (UTC) - 1:29:23 - train - INFO - step: 000384 - done (%): 76.8 - loss: 1.251 - lr: 8.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.0 - avg_words_per_second: 4736.8 - ETA: >2024-05-25 23:42:48 +2024-05-25 23:16:15 (UTC) - 1:29:35 - train - INFO - step: 000385 - done (%): 77.0 - loss: 1.230 - lr: 8.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.2 - avg_words_per_second: 4738.6 - ETA: >2024-05-25 23:42:46 +2024-05-25 23:16:27 (UTC) - 1:29:46 - train - INFO - step: 000386 - done (%): 77.2 - loss: 1.359 - lr: 8.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.4 - avg_words_per_second: 4740.4 - ETA: >2024-05-25 23:42:43 +2024-05-25 23:16:39 (UTC) - 1:29:58 - train - INFO - step: 000387 - done (%): 77.4 - loss: 1.069 - lr: 8.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.5 - avg_words_per_second: 4742.1 - ETA: >2024-05-25 23:42:41 +2024-05-25 23:16:51 (UTC) - 1:30:10 - train - INFO - step: 000388 - done (%): 77.6 - loss: 1.511 - lr: 7.9e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.7 - avg_words_per_second: 4743.8 - ETA: >2024-05-25 23:42:38 +2024-05-25 23:17:03 (UTC) - 1:30:22 - train - INFO - step: 000389 - done (%): 77.8 - loss: 1.536 - lr: 7.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.6 - avg_words_per_second: 4745.6 - ETA: >2024-05-25 23:42:35 +2024-05-25 23:17:14 (UTC) - 1:30:34 - train - INFO - step: 000390 - done (%): 78.0 - loss: 1.264 - lr: 7.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.1 - avg_words_per_second: 4747.3 - ETA: >2024-05-25 23:42:33 +2024-05-25 23:17:26 (UTC) - 1:30:46 - train - INFO - step: 000391 - done (%): 78.2 - loss: 1.485 - lr: 7.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.6 - avg_words_per_second: 4749.0 - ETA: >2024-05-25 23:42:30 +2024-05-25 23:17:38 (UTC) - 1:30:58 - train - INFO - step: 000392 - done (%): 78.4 - loss: 1.789 - lr: 7.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.6 - avg_words_per_second: 4750.8 - ETA: >2024-05-25 23:42:28 +2024-05-25 23:17:50 (UTC) - 1:31:09 - train - INFO - step: 000393 - done (%): 78.6 - loss: 1.360 - lr: 7.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.7 - avg_words_per_second: 4752.5 - ETA: >2024-05-25 23:42:25 +2024-05-25 23:18:02 (UTC) - 1:31:21 - train - INFO - step: 000394 - done (%): 78.8 - loss: 1.210 - lr: 7.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.6 - avg_words_per_second: 4754.2 - ETA: >2024-05-25 23:42:23 +2024-05-25 23:18:14 (UTC) - 1:31:33 - train - INFO - step: 000395 - done (%): 79.0 - loss: 1.167 - lr: 6.9e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.0 - avg_words_per_second: 4755.9 - ETA: >2024-05-25 23:42:20 +2024-05-25 23:18:25 (UTC) - 1:31:45 - train - INFO - step: 000396 - done (%): 79.2 - loss: 1.363 - lr: 6.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.1 - avg_words_per_second: 4757.6 - ETA: >2024-05-25 23:42:18 +2024-05-25 23:18:37 (UTC) - 1:31:57 - train - INFO - step: 000397 - done (%): 79.4 - loss: 1.483 - lr: 6.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.1 - avg_words_per_second: 4759.3 - ETA: >2024-05-25 23:42:16 +2024-05-25 23:18:49 (UTC) - 1:32:09 - train - INFO - step: 000398 - done (%): 79.6 - loss: 1.338 - lr: 6.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.2 - avg_words_per_second: 4761.0 - ETA: >2024-05-25 23:42:13 +2024-05-25 23:19:01 (UTC) - 1:32:20 - train - INFO - step: 000399 - done (%): 79.8 - loss: 1.236 - lr: 6.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.8 - avg_words_per_second: 4762.6 - ETA: >2024-05-25 23:42:11 +2024-05-25 23:19:13 (UTC) - 1:32:32 - train - INFO - step: 000400 - done (%): 80.0 - loss: 1.424 - lr: 6.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.1 - avg_words_per_second: 4764.3 - ETA: >2024-05-25 23:42:08 +2024-05-25 23:19:13 (UTC) - 1:32:32 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runseed5/checkpoints/checkpoint_000400/consolidated using tmp name: tmp.consolidated +2024-05-25 23:19:27 (UTC) - 1:32:47 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runseed5/checkpoints/checkpoint_000400/consolidated for step: 400 +2024-05-25 23:19:28 (UTC) - 1:32:47 - checkpointing - INFO - Deleted ckpt: /root/mistral-finetune/runseed5/checkpoints/checkpoint_000100 +2024-05-25 23:19:28 (UTC) - 1:32:47 - checkpointing - INFO - Done deleting checkpoints /root/mistral-finetune/runseed5/checkpoints/checkpoint_000100 +2024-05-25 23:19:28 (UTC) - 1:32:47 - checkpointing - INFO - Done! +2024-05-25 23:19:40 (UTC) - 1:32:59 - train - INFO - step: 000401 - done (%): 80.2 - loss: 1.077 - lr: 6.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5606.8 - avg_words_per_second: 4766.1 - ETA: >2024-05-25 23:42:21 +2024-05-25 23:19:51 (UTC) - 1:33:11 - train - INFO - step: 000402 - done (%): 80.4 - loss: 1.377 - lr: 6.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5566.8 - avg_words_per_second: 4767.8 - ETA: >2024-05-25 23:42:18 +2024-05-25 23:20:03 (UTC) - 1:33:23 - train - INFO - step: 000403 - done (%): 80.6 - loss: 1.233 - lr: 6.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5548.7 - avg_words_per_second: 4769.4 - ETA: >2024-05-25 23:42:16 +2024-05-25 23:20:15 (UTC) - 1:33:35 - train - INFO - step: 000404 - done (%): 80.8 - loss: 1.095 - lr: 5.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.5 - avg_words_per_second: 4771.1 - ETA: >2024-05-25 23:42:14 +2024-05-25 23:20:27 (UTC) - 1:33:46 - train - INFO - step: 000405 - done (%): 81.0 - loss: 1.492 - lr: 5.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.4 - avg_words_per_second: 4772.7 - ETA: >2024-05-25 23:42:11 +2024-05-25 23:20:39 (UTC) - 1:33:58 - train - INFO - step: 000406 - done (%): 81.2 - loss: 1.291 - lr: 5.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5526.7 - avg_words_per_second: 4774.3 - ETA: >2024-05-25 23:42:09 +2024-05-25 23:20:51 (UTC) - 1:34:10 - train - INFO - step: 000407 - done (%): 81.4 - loss: 1.561 - lr: 5.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.1 - avg_words_per_second: 4775.9 - ETA: >2024-05-25 23:42:07 +2024-05-25 23:21:02 (UTC) - 1:34:22 - train - INFO - step: 000408 - done (%): 81.6 - loss: 1.230 - lr: 5.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.0 - avg_words_per_second: 4777.5 - ETA: >2024-05-25 23:42:04 +2024-05-25 23:21:14 (UTC) - 1:34:34 - train - INFO - step: 000409 - done (%): 81.8 - loss: 1.731 - lr: 5.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.6 - avg_words_per_second: 4779.1 - ETA: >2024-05-25 23:42:02 +2024-05-25 23:21:26 (UTC) - 1:34:46 - train - INFO - step: 000410 - done (%): 82.0 - loss: 1.481 - lr: 5.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.1 - avg_words_per_second: 4780.7 - ETA: >2024-05-25 23:42:00 +2024-05-25 23:21:38 (UTC) - 1:34:57 - train - INFO - step: 000411 - done (%): 82.2 - loss: 1.634 - lr: 5.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.6 - avg_words_per_second: 4782.3 - ETA: >2024-05-25 23:41:58 +2024-05-25 23:21:50 (UTC) - 1:35:09 - train - INFO - step: 000412 - done (%): 82.4 - loss: 1.352 - lr: 4.9e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.4 - avg_words_per_second: 4783.9 - ETA: >2024-05-25 23:41:55 +2024-05-25 23:22:02 (UTC) - 1:35:21 - train - INFO - step: 000413 - done (%): 82.6 - loss: 1.451 - lr: 4.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.1 - avg_words_per_second: 4785.5 - ETA: >2024-05-25 23:41:53 +2024-05-25 23:22:13 (UTC) - 1:35:33 - train - INFO - step: 000414 - done (%): 82.8 - loss: 1.380 - lr: 4.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.5 - avg_words_per_second: 4787.1 - ETA: >2024-05-25 23:41:51 +2024-05-25 23:22:25 (UTC) - 1:35:45 - train - INFO - step: 000415 - done (%): 83.0 - loss: 1.538 - lr: 4.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.9 - avg_words_per_second: 4788.6 - ETA: >2024-05-25 23:41:49 +2024-05-25 23:22:37 (UTC) - 1:35:57 - train - INFO - step: 000416 - done (%): 83.2 - loss: 1.893 - lr: 4.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.7 - avg_words_per_second: 4790.2 - ETA: >2024-05-25 23:41:46 +2024-05-25 23:22:49 (UTC) - 1:36:08 - train - INFO - step: 000417 - done (%): 83.4 - loss: 1.469 - lr: 4.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.8 - avg_words_per_second: 4791.7 - ETA: >2024-05-25 23:41:44 +2024-05-25 23:23:01 (UTC) - 1:36:20 - train - INFO - step: 000418 - done (%): 83.6 - loss: 1.383 - lr: 4.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.4 - avg_words_per_second: 4793.2 - ETA: >2024-05-25 23:41:42 +2024-05-25 23:23:13 (UTC) - 1:36:32 - train - INFO - step: 000419 - done (%): 83.8 - loss: 1.206 - lr: 4.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5548.5 - avg_words_per_second: 4794.8 - ETA: >2024-05-25 23:41:40 +2024-05-25 23:23:24 (UTC) - 1:36:44 - train - INFO - step: 000420 - done (%): 84.0 - loss: 1.500 - lr: 4.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5545.8 - avg_words_per_second: 4796.4 - ETA: >2024-05-25 23:41:38 +2024-05-25 23:23:36 (UTC) - 1:36:56 - train - INFO - step: 000421 - done (%): 84.2 - loss: 1.674 - lr: 4.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5543.7 - avg_words_per_second: 4797.9 - ETA: >2024-05-25 23:41:35 +2024-05-25 23:23:48 (UTC) - 1:37:08 - train - INFO - step: 000422 - done (%): 84.4 - loss: 1.102 - lr: 3.9e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.2 - avg_words_per_second: 4799.4 - ETA: >2024-05-25 23:41:33 +2024-05-25 23:24:00 (UTC) - 1:37:19 - train - INFO - step: 000423 - done (%): 84.6 - loss: 1.357 - lr: 3.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.1 - avg_words_per_second: 4800.9 - ETA: >2024-05-25 23:41:31 +2024-05-25 23:24:12 (UTC) - 1:37:31 - train - INFO - step: 000424 - done (%): 84.8 - loss: 1.255 - lr: 3.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.9 - avg_words_per_second: 4802.4 - ETA: >2024-05-25 23:41:29 +2024-05-25 23:24:24 (UTC) - 1:37:43 - train - INFO - step: 000425 - done (%): 85.0 - loss: 1.207 - lr: 3.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.4 - avg_words_per_second: 4803.9 - ETA: >2024-05-25 23:41:27 +2024-05-25 23:24:35 (UTC) - 1:37:55 - train - INFO - step: 000426 - done (%): 85.2 - loss: 1.114 - lr: 3.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.2 - avg_words_per_second: 4805.4 - ETA: >2024-05-25 23:41:25 +2024-05-25 23:24:47 (UTC) - 1:38:07 - train - INFO - step: 000427 - done (%): 85.4 - loss: 1.556 - lr: 3.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.6 - avg_words_per_second: 4806.9 - ETA: >2024-05-25 23:41:22 +2024-05-25 23:24:59 (UTC) - 1:38:19 - train - INFO - step: 000428 - done (%): 85.6 - loss: 1.464 - lr: 3.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.1 - avg_words_per_second: 4808.4 - ETA: >2024-05-25 23:41:20 +2024-05-25 23:25:11 (UTC) - 1:38:30 - train - INFO - step: 000429 - done (%): 85.8 - loss: 1.224 - lr: 3.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.0 - avg_words_per_second: 4809.9 - ETA: >2024-05-25 23:41:18 +2024-05-25 23:25:23 (UTC) - 1:38:42 - train - INFO - step: 000430 - done (%): 86.0 - loss: 1.508 - lr: 3.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5552.7 - avg_words_per_second: 4811.4 - ETA: >2024-05-25 23:41:16 +2024-05-25 23:25:35 (UTC) - 1:38:54 - train - INFO - step: 000431 - done (%): 86.2 - loss: 1.482 - lr: 3.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.8 - avg_words_per_second: 4812.8 - ETA: >2024-05-25 23:41:14 +2024-05-25 23:25:46 (UTC) - 1:39:06 - train - INFO - step: 000432 - done (%): 86.4 - loss: 1.239 - lr: 3.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.4 - avg_words_per_second: 4814.3 - ETA: >2024-05-25 23:41:12 +2024-05-25 23:25:58 (UTC) - 1:39:18 - train - INFO - step: 000433 - done (%): 86.6 - loss: 1.235 - lr: 2.9e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.5 - avg_words_per_second: 4815.7 - ETA: >2024-05-25 23:41:10 +2024-05-25 23:26:10 (UTC) - 1:39:30 - train - INFO - step: 000434 - done (%): 86.8 - loss: 1.342 - lr: 2.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5521.2 - avg_words_per_second: 4817.2 - ETA: >2024-05-25 23:41:08 +2024-05-25 23:26:22 (UTC) - 1:39:41 - train - INFO - step: 000435 - done (%): 87.0 - loss: 1.733 - lr: 2.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.9 - avg_words_per_second: 4818.6 - ETA: >2024-05-25 23:41:06 +2024-05-25 23:26:34 (UTC) - 1:39:53 - train - INFO - step: 000436 - done (%): 87.2 - loss: 1.642 - lr: 2.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5547.3 - avg_words_per_second: 4820.0 - ETA: >2024-05-25 23:41:04 +2024-05-25 23:26:46 (UTC) - 1:40:05 - train - INFO - step: 000437 - done (%): 87.4 - loss: 1.226 - lr: 2.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5546.9 - avg_words_per_second: 4821.5 - ETA: >2024-05-25 23:41:02 +2024-05-25 23:26:57 (UTC) - 1:40:17 - train - INFO - step: 000438 - done (%): 87.6 - loss: 1.192 - lr: 2.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5545.1 - avg_words_per_second: 4822.9 - ETA: >2024-05-25 23:41:00 +2024-05-25 23:27:09 (UTC) - 1:40:29 - train - INFO - step: 000439 - done (%): 87.8 - loss: 1.534 - lr: 2.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.1 - avg_words_per_second: 4824.4 - ETA: >2024-05-25 23:40:58 +2024-05-25 23:27:21 (UTC) - 1:40:41 - train - INFO - step: 000440 - done (%): 88.0 - loss: 1.528 - lr: 2.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.1 - avg_words_per_second: 4825.8 - ETA: >2024-05-25 23:40:56 +2024-05-25 23:27:33 (UTC) - 1:40:52 - train - INFO - step: 000441 - done (%): 88.2 - loss: 1.444 - lr: 2.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.9 - avg_words_per_second: 4827.2 - ETA: >2024-05-25 23:40:54 +2024-05-25 23:27:45 (UTC) - 1:41:04 - train - INFO - step: 000442 - done (%): 88.4 - loss: 1.447 - lr: 2.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.3 - avg_words_per_second: 4828.6 - ETA: >2024-05-25 23:40:52 +2024-05-25 23:27:57 (UTC) - 1:41:16 - train - INFO - step: 000443 - done (%): 88.6 - loss: 1.414 - lr: 2.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.2 - avg_words_per_second: 4830.0 - ETA: >2024-05-25 23:40:50 +2024-05-25 23:28:08 (UTC) - 1:41:28 - train - INFO - step: 000444 - done (%): 88.8 - loss: 1.568 - lr: 2.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.5 - avg_words_per_second: 4831.4 - ETA: >2024-05-25 23:40:48 +2024-05-25 23:28:20 (UTC) - 1:41:40 - train - INFO - step: 000445 - done (%): 89.0 - loss: 1.299 - lr: 2.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.4 - avg_words_per_second: 4832.7 - ETA: >2024-05-25 23:40:46 +2024-05-25 23:28:32 (UTC) - 1:41:52 - train - INFO - step: 000446 - done (%): 89.2 - loss: 1.262 - lr: 1.9e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.0 - avg_words_per_second: 4834.1 - ETA: >2024-05-25 23:40:44 +2024-05-25 23:28:44 (UTC) - 1:42:03 - train - INFO - step: 000447 - done (%): 89.4 - loss: 1.323 - lr: 1.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5544.4 - avg_words_per_second: 4835.5 - ETA: >2024-05-25 23:40:42 +2024-05-25 23:28:56 (UTC) - 1:42:15 - train - INFO - step: 000448 - done (%): 89.6 - loss: 1.818 - lr: 1.8e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.6 - avg_words_per_second: 4836.9 - ETA: >2024-05-25 23:40:40 +2024-05-25 23:29:08 (UTC) - 1:42:27 - train - INFO - step: 000449 - done (%): 89.8 - loss: 1.538 - lr: 1.7e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.0 - avg_words_per_second: 4838.2 - ETA: >2024-05-25 23:40:38 +2024-05-25 23:29:19 (UTC) - 1:42:39 - train - INFO - step: 000450 - done (%): 90.0 - loss: 1.573 - lr: 1.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.6 - avg_words_per_second: 4839.6 - ETA: >2024-05-25 23:40:37 +2024-05-25 23:29:31 (UTC) - 1:42:51 - train - INFO - step: 000451 - done (%): 90.2 - loss: 1.229 - lr: 1.6e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.3 - avg_words_per_second: 4840.9 - ETA: >2024-05-25 23:40:35 +2024-05-25 23:29:43 (UTC) - 1:43:03 - train - INFO - step: 000452 - done (%): 90.4 - loss: 1.313 - lr: 1.5e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.9 - avg_words_per_second: 4842.3 - ETA: >2024-05-25 23:40:33 +2024-05-25 23:29:55 (UTC) - 1:43:14 - train - INFO - step: 000453 - done (%): 90.6 - loss: 1.196 - lr: 1.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.5 - avg_words_per_second: 4843.6 - ETA: >2024-05-25 23:40:31 +2024-05-25 23:30:07 (UTC) - 1:43:26 - train - INFO - step: 000454 - done (%): 90.8 - loss: 1.496 - lr: 1.4e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.1 - avg_words_per_second: 4844.9 - ETA: >2024-05-25 23:40:29 +2024-05-25 23:30:19 (UTC) - 1:43:38 - train - INFO - step: 000455 - done (%): 91.0 - loss: 1.299 - lr: 1.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.5 - avg_words_per_second: 4846.3 - ETA: >2024-05-25 23:40:27 +2024-05-25 23:30:30 (UTC) - 1:43:50 - train - INFO - step: 000456 - done (%): 91.2 - loss: 1.780 - lr: 1.3e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.6 - avg_words_per_second: 4847.6 - ETA: >2024-05-25 23:40:25 +2024-05-25 23:30:42 (UTC) - 1:44:02 - train - INFO - step: 000457 - done (%): 91.4 - loss: 1.160 - lr: 1.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.6 - avg_words_per_second: 4848.9 - ETA: >2024-05-25 23:40:24 +2024-05-25 23:30:54 (UTC) - 1:44:14 - train - INFO - step: 000458 - done (%): 91.6 - loss: 1.724 - lr: 1.2e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.5 - avg_words_per_second: 4850.2 - ETA: >2024-05-25 23:40:22 +2024-05-25 23:31:06 (UTC) - 1:44:26 - train - INFO - step: 000459 - done (%): 91.8 - loss: 1.454 - lr: 1.1e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5538.1 - avg_words_per_second: 4851.5 - ETA: >2024-05-25 23:40:20 +2024-05-25 23:31:18 (UTC) - 1:44:37 - train - INFO - step: 000460 - done (%): 92.0 - loss: 1.251 - lr: 1.0e-06 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.4 - avg_words_per_second: 4852.8 - ETA: >2024-05-25 23:40:18 +2024-05-25 23:31:30 (UTC) - 1:44:49 - train - INFO - step: 000461 - done (%): 92.2 - loss: 1.350 - lr: 9.9e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.5 - avg_words_per_second: 4854.1 - ETA: >2024-05-25 23:40:16 +2024-05-25 23:31:42 (UTC) - 1:45:01 - train - INFO - step: 000462 - done (%): 92.4 - loss: 1.429 - lr: 9.4e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.5 - avg_words_per_second: 4855.4 - ETA: >2024-05-25 23:40:14 +2024-05-25 23:31:53 (UTC) - 1:45:13 - train - INFO - step: 000463 - done (%): 92.6 - loss: 1.163 - lr: 8.9e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.7 - avg_words_per_second: 4856.7 - ETA: >2024-05-25 23:40:13 +2024-05-25 23:32:05 (UTC) - 1:45:25 - train - INFO - step: 000464 - done (%): 92.8 - loss: 1.526 - lr: 8.5e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.9 - avg_words_per_second: 4858.0 - ETA: >2024-05-25 23:40:11 +2024-05-25 23:32:17 (UTC) - 1:45:37 - train - INFO - step: 000465 - done (%): 93.0 - loss: 1.675 - lr: 8.0e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.4 - avg_words_per_second: 4859.3 - ETA: >2024-05-25 23:40:09 +2024-05-25 23:32:29 (UTC) - 1:45:48 - train - INFO - step: 000466 - done (%): 93.2 - loss: 1.866 - lr: 7.6e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.4 - avg_words_per_second: 4860.6 - ETA: >2024-05-25 23:40:07 +2024-05-25 23:32:41 (UTC) - 1:46:00 - train - INFO - step: 000467 - done (%): 93.4 - loss: 1.326 - lr: 7.1e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5541.7 - avg_words_per_second: 4861.9 - ETA: >2024-05-25 23:40:05 +2024-05-25 23:32:53 (UTC) - 1:46:12 - train - INFO - step: 000468 - done (%): 93.6 - loss: 1.136 - lr: 6.7e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.1 - avg_words_per_second: 4863.1 - ETA: >2024-05-25 23:40:04 +2024-05-25 23:33:04 (UTC) - 1:46:24 - train - INFO - step: 000469 - done (%): 93.8 - loss: 1.483 - lr: 6.3e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.0 - avg_words_per_second: 4864.4 - ETA: >2024-05-25 23:40:02 +2024-05-25 23:33:28 (UTC) - 1:46:47 - train - INFO - step: 000470 - done (%): 94.0 - loss: 1.345 - lr: 5.9e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 2818.4 - avg_words_per_second: 4856.9 - ETA: >2024-05-25 23:40:12 +2024-05-25 23:33:39 (UTC) - 1:46:59 - train - INFO - step: 000471 - done (%): 94.2 - loss: 1.299 - lr: 5.5e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5565.8 - avg_words_per_second: 4858.2 - ETA: >2024-05-25 23:40:11 +2024-05-25 23:33:51 (UTC) - 1:47:11 - train - INFO - step: 000472 - done (%): 94.4 - loss: 1.494 - lr: 5.1e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5542.0 - avg_words_per_second: 4859.5 - ETA: >2024-05-25 23:40:09 +2024-05-25 23:34:03 (UTC) - 1:47:23 - train - INFO - step: 000473 - done (%): 94.6 - loss: 1.573 - lr: 4.8e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.6 - avg_words_per_second: 4860.7 - ETA: >2024-05-25 23:40:07 +2024-05-25 23:34:15 (UTC) - 1:47:34 - train - INFO - step: 000474 - done (%): 94.8 - loss: 1.278 - lr: 4.4e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.6 - avg_words_per_second: 4862.0 - ETA: >2024-05-25 23:40:05 +2024-05-25 23:34:27 (UTC) - 1:47:46 - train - INFO - step: 000475 - done (%): 95.0 - loss: 1.504 - lr: 4.1e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5534.5 - avg_words_per_second: 4863.2 - ETA: >2024-05-25 23:40:04 +2024-05-25 23:34:39 (UTC) - 1:47:58 - train - INFO - step: 000476 - done (%): 95.2 - loss: 1.486 - lr: 3.8e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.5 - avg_words_per_second: 4864.5 - ETA: >2024-05-25 23:40:02 +2024-05-25 23:34:50 (UTC) - 1:48:10 - train - INFO - step: 000477 - done (%): 95.4 - loss: 1.377 - lr: 3.5e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.3 - avg_words_per_second: 4865.7 - ETA: >2024-05-25 23:40:00 +2024-05-25 23:35:02 (UTC) - 1:48:22 - train - INFO - step: 000478 - done (%): 95.6 - loss: 1.727 - lr: 3.2e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.6 - avg_words_per_second: 4866.9 - ETA: >2024-05-25 23:39:59 +2024-05-25 23:35:14 (UTC) - 1:48:34 - train - INFO - step: 000479 - done (%): 95.8 - loss: 1.266 - lr: 2.9e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5522.3 - avg_words_per_second: 4868.1 - ETA: >2024-05-25 23:39:57 +2024-05-25 23:35:26 (UTC) - 1:48:46 - train - INFO - step: 000480 - done (%): 96.0 - loss: 1.332 - lr: 2.6e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5539.5 - avg_words_per_second: 4869.3 - ETA: >2024-05-25 23:39:55 +2024-05-25 23:35:38 (UTC) - 1:48:57 - train - INFO - step: 000481 - done (%): 96.2 - loss: 1.463 - lr: 2.4e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.1 - avg_words_per_second: 4870.6 - ETA: >2024-05-25 23:39:54 +2024-05-25 23:35:50 (UTC) - 1:49:09 - train - INFO - step: 000482 - done (%): 96.4 - loss: 1.158 - lr: 2.1e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.9 - avg_words_per_second: 4871.8 - ETA: >2024-05-25 23:39:52 +2024-05-25 23:36:02 (UTC) - 1:49:21 - train - INFO - step: 000483 - done (%): 96.6 - loss: 1.384 - lr: 1.9e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.4 - avg_words_per_second: 4873.0 - ETA: >2024-05-25 23:39:50 +2024-05-25 23:36:13 (UTC) - 1:49:33 - train - INFO - step: 000484 - done (%): 96.8 - loss: 1.282 - lr: 1.7e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.0 - avg_words_per_second: 4874.2 - ETA: >2024-05-25 23:39:49 +2024-05-25 23:36:25 (UTC) - 1:49:45 - train - INFO - step: 000485 - done (%): 97.0 - loss: 1.392 - lr: 1.5e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.2 - avg_words_per_second: 4875.4 - ETA: >2024-05-25 23:39:47 +2024-05-25 23:36:37 (UTC) - 1:49:57 - train - INFO - step: 000486 - done (%): 97.2 - loss: 1.775 - lr: 1.3e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5517.3 - avg_words_per_second: 4876.5 - ETA: >2024-05-25 23:39:45 +2024-05-25 23:36:49 (UTC) - 1:50:08 - train - INFO - step: 000487 - done (%): 97.4 - loss: 1.305 - lr: 1.1e-07 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.9 - avg_words_per_second: 4877.7 - ETA: >2024-05-25 23:39:44 +2024-05-25 23:37:01 (UTC) - 1:50:20 - train - INFO - step: 000488 - done (%): 97.6 - loss: 1.311 - lr: 9.5e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.2 - avg_words_per_second: 4878.9 - ETA: >2024-05-25 23:39:42 +2024-05-25 23:37:13 (UTC) - 1:50:32 - train - INFO - step: 000489 - done (%): 97.8 - loss: 1.443 - lr: 8.0e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5533.1 - avg_words_per_second: 4880.1 - ETA: >2024-05-25 23:39:40 +2024-05-25 23:37:24 (UTC) - 1:50:44 - train - INFO - step: 000490 - done (%): 98.0 - loss: 1.190 - lr: 6.6e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5536.8 - avg_words_per_second: 4881.3 - ETA: >2024-05-25 23:39:39 +2024-05-25 23:37:36 (UTC) - 1:50:56 - train - INFO - step: 000491 - done (%): 98.2 - loss: 1.498 - lr: 5.3e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5540.3 - avg_words_per_second: 4882.5 - ETA: >2024-05-25 23:39:37 +2024-05-25 23:37:48 (UTC) - 1:51:08 - train - INFO - step: 000492 - done (%): 98.4 - loss: 1.326 - lr: 4.2e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5531.8 - avg_words_per_second: 4883.6 - ETA: >2024-05-25 23:39:36 +2024-05-25 23:38:00 (UTC) - 1:51:20 - train - INFO - step: 000493 - done (%): 98.6 - loss: 1.438 - lr: 3.2e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5535.2 - avg_words_per_second: 4884.8 - ETA: >2024-05-25 23:39:34 +2024-05-25 23:38:12 (UTC) - 1:51:31 - train - INFO - step: 000494 - done (%): 98.8 - loss: 1.261 - lr: 2.4e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5537.0 - avg_words_per_second: 4886.0 - ETA: >2024-05-25 23:39:32 +2024-05-25 23:38:24 (UTC) - 1:51:43 - train - INFO - step: 000495 - done (%): 99.0 - loss: 1.314 - lr: 1.7e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5527.3 - avg_words_per_second: 4887.1 - ETA: >2024-05-25 23:39:31 +2024-05-25 23:38:36 (UTC) - 1:51:55 - train - INFO - step: 000496 - done (%): 99.2 - loss: 1.184 - lr: 1.1e-08 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5524.9 - avg_words_per_second: 4888.2 - ETA: >2024-05-25 23:39:29 +2024-05-25 23:38:47 (UTC) - 1:52:07 - train - INFO - step: 000497 - done (%): 99.4 - loss: 1.244 - lr: 6.1e-09 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5529.0 - avg_words_per_second: 4889.4 - ETA: >2024-05-25 23:39:28 +2024-05-25 23:38:59 (UTC) - 1:52:19 - train - INFO - step: 000498 - done (%): 99.6 - loss: 1.390 - lr: 2.9e-09 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5532.7 - avg_words_per_second: 4890.5 - ETA: >2024-05-25 23:39:26 +2024-05-25 23:39:11 (UTC) - 1:52:31 - train - INFO - step: 000499 - done (%): 99.8 - loss: 1.459 - lr: 9.0e-10 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5530.5 - avg_words_per_second: 4891.7 - ETA: >2024-05-25 23:39:25 +2024-05-25 23:39:23 (UTC) - 1:52:42 - train - INFO - step: 000500 - done (%): 100.0 - loss: 1.562 - lr: 2.4e-10 - peak_alloc_mem (GB): 64.9 - alloc_mem (GB): 24.1 - words_per_second: 5528.8 - avg_words_per_second: 4892.8 - ETA: >2024-05-25 23:39:23 +2024-05-25 23:39:23 (UTC) - 1:52:42 - checkpointing - INFO - Dumping checkpoint in /root/mistral-finetune/runseed5/checkpoints/checkpoint_000500/consolidated using tmp name: tmp.consolidated +2024-05-25 23:39:37 (UTC) - 1:52:57 - checkpointing - INFO - Done dumping checkpoint in /root/mistral-finetune/runseed5/checkpoints/checkpoint_000500/consolidated for step: 500 +2024-05-25 23:39:38 (UTC) - 1:52:58 - checkpointing - INFO - Deleted ckpt: /root/mistral-finetune/runseed5/checkpoints/checkpoint_000200 +2024-05-25 23:39:38 (UTC) - 1:52:58 - checkpointing - INFO - Done deleting checkpoints /root/mistral-finetune/runseed5/checkpoints/checkpoint_000200 +2024-05-25 23:39:38 (UTC) - 1:52:58 - checkpointing - INFO - Done! +2024-05-25 23:39:38 (UTC) - 1:52:58 - train - INFO - done! +2024-05-25 23:39:38 (UTC) - 1:52:58 - utils - INFO - Closing: eval_logger \ No newline at end of file diff --git a/runseed5/wandb/run-20240525_214643-cngfo6vp/files/requirements.txt b/runseed5/wandb/run-20240525_214643-cngfo6vp/files/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..f173be0be357b3fd62b7aba8d8c38a23b90cdc07 --- /dev/null +++ b/runseed5/wandb/run-20240525_214643-cngfo6vp/files/requirements.txt @@ -0,0 +1,67 @@ +GitPython==3.1.43 +Jinja2==3.1.4 +Markdown==3.6 +MarkupSafe==2.1.5 +PyYAML==6.0.1 +Werkzeug==3.0.3 +absl-py==2.1.0 +annotated-types==0.7.0 +attrs==23.2.0 +certifi==2024.2.2 +charset-normalizer==3.3.2 +click==8.1.7 +docker-pycreds==0.4.0 +docstring_parser==0.16 +filelock==3.14.0 +fire==0.6.0 +fsspec==2024.5.0 +gitdb==4.0.11 +grpcio==1.64.0 +idna==3.7 +jsonschema-specifications==2023.12.1 +jsonschema==4.21.1 +mistral_common==1.1.0 +mpmath==1.3.0 +networkx==3.3 +numpy==1.26.4 +nvidia-cublas-cu12==12.1.3.1 +nvidia-cuda-cupti-cu12==12.1.105 +nvidia-cuda-nvrtc-cu12==12.1.105 +nvidia-cuda-runtime-cu12==12.1.105 +nvidia-cudnn-cu12==8.9.2.26 +nvidia-cufft-cu12==11.0.2.54 +nvidia-curand-cu12==10.3.2.106 +nvidia-cusolver-cu12==11.4.5.107 +nvidia-cusparse-cu12==12.1.0.106 +nvidia-nccl-cu12==2.19.3 +nvidia-nvjitlink-cu12==12.5.40 +nvidia-nvtx-cu12==12.1.105 +pip==24.0 +platformdirs==4.2.2 +protobuf==4.25.3 +psutil==5.9.8 +pydantic==2.6.1 +pydantic_core==2.16.2 +referencing==0.35.1 +requests==2.32.2 +rpds-py==0.18.1 +safetensors==0.4.3 +sentencepiece==0.1.99 +sentry-sdk==2.3.1 +setproctitle==1.3.3 +setuptools==69.5.1 +simple_parsing==0.1.5 +six==1.16.0 +smmap==5.0.1 +sympy==1.12 +tensorboard-data-server==0.7.2 +tensorboard==2.16.2 +termcolor==2.4.0 +torch==2.2.0 +tqdm==4.66.4 +triton==2.2.0 +typing_extensions==4.12.0 +urllib3==2.2.1 +wandb==0.17.0 +wheel==0.43.0 +xformers==0.0.24 \ No newline at end of file diff --git a/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-metadata.json b/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..d053579ca0cc0201cf5a8ffca2f10611aee87c34 --- /dev/null +++ b/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-metadata.json @@ -0,0 +1,169 @@ +{ + "os": "Linux-5.15.0-102-generic-x86_64-with-glibc2.35", + "python": "3.10.14", + "heartbeatAt": "2024-05-25T21:46:43.923639", + "startedAt": "2024-05-25T21:46:43.429708", + "docker": null, + "cuda": null, + "args": [ + "example/7B.yaml" + ], + "state": "running", + "program": "-m train", + "codePathLocal": null, + "git": { + "remote": "https://github.com/mistralai/mistral-finetune.git", + "commit": "cb892f012ef940bc741dd3b043bc1d06f0cf6085" + }, + "email": "clement.castellon@gmail.com", + "root": "/root/mistral-finetune", + "host": "scw-tender-archimedes", + "username": "root", + "executable": "/root/miniconda/envs/chemistralpy310/bin/python", + "cpu_count": 24, + "cpu_count_logical": 24, + "cpu_freq": { + "current": 2699.9959999999996, + "min": 0.0, + "max": 0.0 + }, + "cpu_freq_per_core": [ + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + } + ], + "disk": { + "/": { + "total": 902.4293403625488, + "used": 190.7148666381836 + } + }, + "gpu": "NVIDIA H100 PCIe", + "gpu_count": 1, + "gpu_devices": [ + { + "name": "NVIDIA H100 PCIe", + "memory_total": 85520809984 + } + ], + "memory": { + "total": 235.9408187866211 + } +} diff --git a/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json b/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json new file mode 100644 index 0000000000000000000000000000000000000000..83ede74073252266a3b3cd84db537faabb9809e9 --- /dev/null +++ b/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json @@ -0,0 +1 @@ +{"train/lr": 2.4e-10, "train/loss": 1.562139868736267, "train/percent_done": 100.0, "train/peak_allocated_mem": 64.85545778274536, "train/allocated_mem": 24.14044427871704, "train/wps": 5528.798504252308, "train/avg_wps": 4892.790575206737, "train/eta_in_seconds": 0.0, "_timestamp": 1716680363.4648325, "_runtime": 6760.032865524292, "_step": 500, "_wandb": {"runtime": 6774}} \ No newline at end of file diff --git a/runseed5/wandb/run-20240525_214643-cngfo6vp/logs/debug-internal.log b/runseed5/wandb/run-20240525_214643-cngfo6vp/logs/debug-internal.log new file mode 100644 index 0000000000000000000000000000000000000000..95cd6639f8749d2434cd377162f1887391f7cbad --- /dev/null +++ b/runseed5/wandb/run-20240525_214643-cngfo6vp/logs/debug-internal.log @@ -0,0 +1,5576 @@ +2024-05-25 21:46:43,432 INFO StreamThr :43320 [internal.py:wandb_internal():85] W&B internal server running at pid: 43320, started at: 2024-05-25 21:46:43.432097 +2024-05-25 21:46:43,433 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status +2024-05-25 21:46:43,434 INFO WriterThread:43320 [datastore.py:open_for_write():87] open: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/run-cngfo6vp.wandb +2024-05-25 21:46:43,436 DEBUG SenderThread:43320 [sender.py:send():378] send: header +2024-05-25 21:46:43,436 DEBUG SenderThread:43320 [sender.py:send():378] send: run +2024-05-25 21:46:43,823 INFO SenderThread:43320 [dir_watcher.py:__init__():211] watching files in: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files +2024-05-25 21:46:43,823 INFO SenderThread:43320 [sender.py:_start_run_threads():1123] run started: cngfo6vp with start time 1716673603.431967 +2024-05-25 21:46:43,827 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: check_version +2024-05-25 21:46:43,827 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: check_version +2024-05-25 21:46:43,906 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: run_start +2024-05-25 21:46:43,911 DEBUG HandlerThread:43320 [system_info.py:__init__():26] System info init +2024-05-25 21:46:43,911 DEBUG HandlerThread:43320 [system_info.py:__init__():41] System info init done +2024-05-25 21:46:43,911 INFO HandlerThread:43320 [system_monitor.py:start():194] Starting system monitor +2024-05-25 21:46:43,911 INFO SystemMonitor:43320 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-05-25 21:46:43,912 INFO HandlerThread:43320 [system_monitor.py:probe():214] Collecting system info +2024-05-25 21:46:43,912 INFO SystemMonitor:43320 [interfaces.py:start():188] Started cpu monitoring +2024-05-25 21:46:43,913 INFO SystemMonitor:43320 [interfaces.py:start():188] Started disk monitoring +2024-05-25 21:46:43,913 INFO SystemMonitor:43320 [interfaces.py:start():188] Started gpu monitoring +2024-05-25 21:46:43,914 INFO SystemMonitor:43320 [interfaces.py:start():188] Started memory monitoring +2024-05-25 21:46:43,915 INFO SystemMonitor:43320 [interfaces.py:start():188] Started network monitoring +2024-05-25 21:46:43,923 DEBUG HandlerThread:43320 [system_info.py:probe():150] Probing system +2024-05-25 21:46:43,924 DEBUG HandlerThread:43320 [system_info.py:_probe_git():135] Probing git +2024-05-25 21:46:43,928 DEBUG HandlerThread:43320 [system_info.py:_probe_git():143] Probing git done +2024-05-25 21:46:43,928 DEBUG HandlerThread:43320 [system_info.py:probe():198] Probing system done +2024-05-25 21:46:43,928 DEBUG HandlerThread:43320 [system_monitor.py:probe():223] {'os': 'Linux-5.15.0-102-generic-x86_64-with-glibc2.35', 'python': '3.10.14', 'heartbeatAt': '2024-05-25T21:46:43.923639', 'startedAt': '2024-05-25T21:46:43.429708', 'docker': None, 'cuda': None, 'args': ('example/7B.yaml',), 'state': 'running', 'program': '-m train', 'codePathLocal': None, 'git': {'remote': 'https://github.com/mistralai/mistral-finetune.git', 'commit': 'cb892f012ef940bc741dd3b043bc1d06f0cf6085'}, 'email': 'clement.castellon@gmail.com', 'root': '/root/mistral-finetune', 'host': 'scw-tender-archimedes', 'username': 'root', 'executable': '/root/miniconda/envs/chemistralpy310/bin/python', 'cpu_count': 24, 'cpu_count_logical': 24, 'cpu_freq': {'current': 2699.9959999999996, 'min': 0.0, 'max': 0.0}, 'cpu_freq_per_core': [{'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}], 'disk': {'/': {'total': 902.4293403625488, 'used': 190.7148666381836}}, 'gpu': 'NVIDIA H100 PCIe', 'gpu_count': 1, 'gpu_devices': [{'name': 'NVIDIA H100 PCIe', 'memory_total': 85520809984}], 'memory': {'total': 235.9408187866211}} +2024-05-25 21:46:43,928 INFO HandlerThread:43320 [system_monitor.py:probe():224] Finished collecting system info +2024-05-25 21:46:43,928 INFO HandlerThread:43320 [system_monitor.py:probe():227] Publishing system info +2024-05-25 21:46:43,928 DEBUG HandlerThread:43320 [system_info.py:_save_conda():207] Saving list of conda packages installed into the current environment +2024-05-25 21:46:44,823 INFO Thread-12 :43320 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/conda-environment.yaml +2024-05-25 21:46:44,893 DEBUG HandlerThread:43320 [system_info.py:_save_conda():222] Saving conda packages done +2024-05-25 21:46:44,893 INFO HandlerThread:43320 [system_monitor.py:probe():229] Finished publishing system info +2024-05-25 21:46:44,896 DEBUG SenderThread:43320 [sender.py:send():378] send: files +2024-05-25 21:46:44,896 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-metadata.json with policy now +2024-05-25 21:46:44,923 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: python_packages +2024-05-25 21:46:44,923 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: python_packages +2024-05-25 21:46:44,923 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:46:44,923 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:46:45,112 DEBUG SenderThread:43320 [sender.py:send():378] send: telemetry +2024-05-25 21:46:45,371 INFO wandb-upload_0:43320 [upload_job.py:push():130] Uploaded file /tmp/tmpr2ktm50cwandb/nymq5ayo-wandb-metadata.json +2024-05-25 21:46:45,823 INFO Thread-12 :43320 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-metadata.json +2024-05-25 21:46:45,823 INFO Thread-12 :43320 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/requirements.txt +2024-05-25 21:46:45,823 INFO Thread-12 :43320 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 21:46:47,824 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 21:46:49,012 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:46:54,012 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:46:59,013 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:46:59,944 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:46:59,944 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:47:04,168 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:47:09,168 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:47:14,171 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:47:14,830 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/config.yaml +2024-05-25 21:47:14,944 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:47:14,945 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:47:20,129 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:47:25,130 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:47:29,965 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:47:29,966 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:47:31,122 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:47:36,122 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:47:41,123 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:47:43,915 DEBUG SystemMonitor:43320 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-05-25 21:47:43,916 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:47:44,982 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:47:44,982 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:47:47,116 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:47:52,117 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:47:57,118 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:47:59,982 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:47:59,982 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:48:02,186 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:48:07,186 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:48:12,187 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:48:13,916 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:48:14,982 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:48:14,982 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:48:18,164 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:48:23,165 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:48:28,166 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:48:29,977 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:48:29,978 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:48:33,172 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:48:38,173 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:48:43,174 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:48:43,917 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:48:45,029 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:48:45,029 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:48:48,259 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:48:53,259 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:48:58,260 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:49:00,009 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:49:00,009 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:49:04,182 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:49:09,183 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:49:13,918 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:49:14,918 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:49:15,035 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:49:15,035 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:49:20,241 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:49:25,242 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:49:30,040 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:49:30,041 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:49:31,180 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:49:36,181 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:49:41,182 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:49:43,918 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:49:45,053 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:49:45,054 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:49:46,276 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:49:51,277 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:49:56,277 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:50:00,062 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:50:00,062 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:50:01,280 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:50:06,281 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:50:11,282 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:50:13,919 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:50:15,062 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:50:15,062 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:50:16,295 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:50:21,296 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:50:26,296 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:50:30,052 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:50:30,052 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:50:32,216 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:50:37,216 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:50:42,217 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:50:43,919 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:50:45,094 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:50:45,094 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:50:47,276 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:50:52,276 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:50:57,277 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:51:00,083 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:51:00,084 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:51:03,215 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:51:08,216 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:51:13,217 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:51:13,920 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:51:15,068 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:51:15,068 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:51:19,213 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:51:24,214 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:51:29,215 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:51:30,073 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:51:30,073 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:51:34,286 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:51:39,287 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:51:43,920 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:51:44,921 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:51:45,089 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:51:45,090 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:51:50,329 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:51:55,330 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:52:00,098 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:52:00,098 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:52:00,337 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:52:05,337 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:52:10,338 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:52:13,921 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:52:15,093 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:52:15,093 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:52:16,322 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:52:21,323 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:52:26,323 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:52:30,098 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:52:30,098 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:52:32,265 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:52:37,266 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:52:42,267 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:52:43,921 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:52:45,088 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:52:45,088 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:52:48,239 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:52:53,239 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:52:58,240 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:53:00,122 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:53:00,122 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:53:03,369 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:53:08,370 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:53:13,371 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:53:13,922 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:53:15,109 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:53:15,109 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:53:19,273 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:53:24,274 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:53:29,275 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:53:30,111 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:53:30,111 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:53:34,314 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:53:39,314 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:53:43,922 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:53:44,923 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:53:45,125 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:53:45,125 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:53:50,308 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:53:55,309 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:54:00,155 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:54:00,155 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:54:00,373 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:54:05,374 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:54:10,374 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:54:13,923 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:54:15,615 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:54:15,646 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:54:15,646 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:54:20,869 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:54:25,870 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:54:30,646 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:54:30,647 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:54:31,822 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:54:36,823 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:54:41,823 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:54:43,923 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:54:45,671 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:54:45,671 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:54:46,862 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:54:51,863 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:54:56,863 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:55:00,646 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:55:00,646 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:55:01,875 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:55:06,875 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:55:11,876 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:55:13,924 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:55:15,672 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:55:15,672 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:55:16,880 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:55:21,881 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:55:26,882 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:55:30,676 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:55:30,676 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:55:32,876 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:55:37,877 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:55:42,878 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:55:43,924 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:55:45,682 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:55:45,682 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:55:48,876 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:55:53,877 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:55:58,878 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:56:00,683 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:56:00,683 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:56:03,892 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:56:08,893 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:56:13,893 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:56:13,924 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:56:15,707 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:56:15,707 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:56:19,852 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:56:24,853 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:56:29,854 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:56:30,676 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:56:30,676 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:56:34,875 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:56:39,876 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:56:43,925 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:56:44,926 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:56:45,712 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:56:45,712 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:56:50,876 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:56:55,876 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:57:00,703 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:57:00,703 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:57:00,901 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:57:05,901 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:57:10,902 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:57:13,925 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:57:15,708 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:57:15,708 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:57:16,895 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:57:21,896 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:57:26,897 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:57:30,700 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:57:30,700 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:57:32,841 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:57:37,842 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:57:42,842 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:57:43,930 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:57:45,705 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:57:45,705 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:57:47,891 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:57:52,891 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:57:57,892 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:58:00,729 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:58:00,729 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:58:02,907 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:58:07,907 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:58:12,908 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:58:13,926 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:58:15,729 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:58:15,729 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:58:17,946 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:58:22,947 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:58:27,948 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:58:30,734 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:58:30,734 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:58:33,833 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:58:38,834 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:58:43,835 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:58:43,928 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:58:47,664 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:58:47,665 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:58:49,797 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:58:54,797 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:59:00,001 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 21:59:00,306 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:59:02,607 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:59:02,607 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:59:05,749 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:59:10,332 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:59:10,333 DEBUG SenderThread:43320 [sender.py:send():378] send: telemetry +2024-05-25 21:59:11,335 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:59:12,003 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/config.yaml +2024-05-25 21:59:12,004 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 21:59:13,928 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:59:16,928 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:59:17,607 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:59:17,607 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:59:21,950 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:59:21,951 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:59:21,951 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 21:59:21,951 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:59:21,951 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:59:22,006 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 21:59:22,006 INFO Thread-12 :43320 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 21:59:26,952 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:59:31,953 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:59:32,607 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:59:32,607 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:59:33,692 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:59:33,693 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 21:59:33,693 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:59:33,693 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:59:34,009 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 21:59:34,009 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 21:59:37,694 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:59:42,695 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:59:43,928 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 21:59:45,462 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:59:45,463 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 21:59:45,463 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:59:45,463 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:59:46,011 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 21:59:47,012 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 21:59:47,607 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 21:59:47,607 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 21:59:47,745 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:59:52,746 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:59:57,257 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 21:59:57,258 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 21:59:57,258 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 21:59:57,258 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 21:59:58,014 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 21:59:58,259 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 21:59:59,014 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:00:02,607 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:00:02,607 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:00:03,857 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:00:08,857 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:00:09,089 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:00:09,089 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:00:09,089 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:00:09,090 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:00:10,016 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:00:11,017 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:00:13,928 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:00:13,930 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:00:17,607 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:00:17,608 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:00:19,757 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:00:20,911 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:00:20,911 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:00:20,911 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:00:20,912 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:00:21,019 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:00:23,019 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:00:24,912 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:00:29,913 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:00:32,607 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:00:32,608 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:00:32,767 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:00:32,767 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:00:32,767 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:00:32,768 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:00:33,021 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:00:35,022 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:00:35,768 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:00:40,769 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:00:43,929 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:00:44,609 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:00:44,610 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:00:44,610 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:00:44,610 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:00:45,024 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:00:46,611 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:00:47,025 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:00:47,607 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:00:47,608 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:00:51,818 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:00:56,435 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:00:56,436 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:00:56,436 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:00:56,436 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:00:57,027 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:00:57,437 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:00:59,027 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:01:02,437 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:01:02,607 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:01:02,608 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:01:07,838 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:01:08,273 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:01:08,274 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:01:08,274 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:01:08,274 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:01:09,030 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:01:11,031 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:01:13,275 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:01:13,929 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:01:17,608 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:01:17,608 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:01:18,785 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:01:20,104 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:01:20,105 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:01:20,105 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:01:20,105 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:01:21,033 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:01:21,033 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:01:24,106 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:01:29,107 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:01:31,936 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:01:31,936 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:01:31,937 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:01:31,937 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:01:32,036 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:01:32,608 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:01:32,608 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:01:33,036 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:01:34,749 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:01:39,750 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:01:43,768 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:01:43,769 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:01:43,769 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:01:43,769 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:01:43,930 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:01:44,039 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:01:44,930 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:01:45,039 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:01:47,608 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:01:47,608 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:01:50,813 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:01:55,624 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:01:55,625 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:01:55,625 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:01:55,625 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:01:56,042 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:01:56,626 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:01:57,042 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:02:01,626 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:02:02,608 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:02:02,609 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:02:06,768 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:02:07,474 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:02:07,475 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:02:07,475 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:02:07,475 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:02:08,045 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:02:09,046 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:02:12,476 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:02:13,930 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:02:17,608 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:02:17,608 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:02:17,825 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:02:19,312 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:02:19,312 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:02:19,312 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:02:19,313 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:02:20,048 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:02:21,049 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:02:23,314 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:02:28,314 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:02:31,168 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:02:31,169 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:02:31,169 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:02:31,169 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:02:32,051 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:02:32,608 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:02:32,608 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:02:33,052 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:02:33,833 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:02:38,834 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:02:43,045 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:02:43,045 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:02:43,046 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:02:43,046 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:02:43,054 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:02:43,931 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:02:43,931 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:02:45,055 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:02:47,608 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:02:47,609 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:02:49,759 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:02:54,760 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:02:54,906 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:02:54,906 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:02:54,906 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:02:54,907 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:02:55,057 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:02:57,058 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:02:59,908 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:03:02,608 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:03:02,609 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:03:05,749 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:03:06,757 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:03:06,758 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:03:06,758 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:03:06,758 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:03:07,060 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:03:09,061 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:03:10,759 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:03:13,931 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:03:15,932 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:03:17,608 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:03:17,609 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:03:18,575 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:03:18,588 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:03:18,588 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:03:18,588 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:03:19,063 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:03:21,064 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:03:21,589 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:03:26,590 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:03:30,410 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:03:30,410 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:03:30,411 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:03:30,411 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:03:31,066 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:03:32,411 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:03:32,609 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:03:32,609 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:03:33,066 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:03:37,814 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:03:42,241 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:03:42,242 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:03:42,242 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:03:42,242 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:03:43,069 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:03:43,069 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:03:43,243 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:03:43,932 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:03:47,609 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:03:47,609 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:03:48,831 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:03:53,831 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:03:54,060 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:03:54,061 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:03:54,061 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:03:54,061 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:03:54,071 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:03:55,071 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:03:59,062 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:04:02,609 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:04:02,609 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:04:04,816 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:04:05,884 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:04:05,884 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:04:05,885 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:04:05,885 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:04:06,074 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:04:07,074 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:04:09,886 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:04:13,932 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:04:14,933 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:04:17,609 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:04:17,609 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:04:17,715 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:04:17,808 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:04:17,809 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:04:17,809 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:04:18,077 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:04:19,077 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:04:20,810 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:04:25,810 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:04:29,545 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:04:29,546 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:04:29,546 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:04:29,546 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:04:30,080 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:04:31,080 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:04:31,547 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:04:32,609 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:04:32,609 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:04:36,846 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:04:41,383 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:04:41,383 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:04:41,384 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:04:41,384 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:04:42,083 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:04:42,384 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:04:43,083 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:04:43,933 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:04:47,609 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:04:47,609 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:04:47,841 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:04:52,842 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:04:53,227 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:04:53,228 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:04:53,228 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:04:53,228 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:04:54,086 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:04:55,087 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:04:58,229 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:05:02,609 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:05:02,609 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:05:03,744 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:05:05,075 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:05:05,075 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:05:05,075 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:05:05,076 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:05:05,089 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:05:07,090 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:05:09,076 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:05:13,933 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:05:14,934 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:05:16,930 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:05:16,931 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:05:16,931 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:05:16,931 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:05:17,092 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:05:17,609 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:05:17,609 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:05:19,093 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:05:20,763 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:05:25,764 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:05:28,782 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:05:28,783 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:05:28,783 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:05:28,783 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:05:29,095 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:05:30,784 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:05:31,096 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:05:32,609 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:05:32,610 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:05:36,769 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:05:40,596 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:05:40,597 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:05:40,597 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:05:40,597 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:05:41,098 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:05:42,598 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:05:43,098 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:05:43,934 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:05:47,609 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:05:47,610 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:05:47,816 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:05:52,413 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:05:52,414 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:05:52,414 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:05:52,414 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:05:53,101 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:05:53,415 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:05:55,101 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:05:58,415 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:06:02,610 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:06:02,610 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:06:03,782 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:06:04,243 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:06:04,243 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:06:04,244 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:06:04,244 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:06:05,104 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:06:05,104 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:06:09,245 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:06:13,934 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:06:14,935 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:06:16,065 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:06:16,066 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:06:16,066 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:06:16,067 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:06:16,107 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:06:17,107 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:06:17,610 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:06:17,610 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:06:20,795 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:06:25,795 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:06:27,878 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:06:27,879 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:06:27,879 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:06:27,879 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:06:28,110 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:06:29,110 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:06:30,880 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:06:32,610 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:06:32,610 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:06:36,847 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:06:39,718 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:06:39,719 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:06:39,719 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:06:39,719 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:06:40,113 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:06:41,113 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:06:42,720 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:06:43,935 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:06:47,610 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:06:47,610 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:06:47,836 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:06:51,557 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:06:51,557 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:06:51,557 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:06:51,558 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:06:52,116 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:06:53,116 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:06:53,558 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:06:58,559 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:07:02,610 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:07:02,610 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:07:03,393 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:07:03,394 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:07:03,394 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:07:03,394 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:07:04,118 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:07:04,395 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:07:05,119 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:07:09,395 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:07:13,935 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:07:14,936 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:07:15,246 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:07:15,247 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:07:15,247 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:07:15,247 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:07:16,121 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:07:17,122 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:07:17,610 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:07:17,611 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:07:20,793 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:07:25,794 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:07:27,066 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:07:27,067 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:07:27,067 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:07:27,067 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:07:27,124 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:07:29,124 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:07:31,068 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:07:32,610 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:07:32,611 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:07:36,800 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:07:38,896 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:07:38,896 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:07:38,897 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:07:38,897 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:07:39,127 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:07:41,127 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:07:41,897 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:07:43,936 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:07:46,937 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:07:47,610 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:07:47,611 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:07:50,745 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:07:50,745 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:07:50,745 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:07:50,746 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:07:51,130 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:07:52,746 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:07:53,130 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:07:57,747 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:08:02,604 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:08:02,605 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:08:02,605 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:08:02,606 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:08:02,615 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:08:02,615 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:08:02,839 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:08:03,132 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:08:05,133 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:08:07,839 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:08:12,840 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:08:13,940 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:08:14,436 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:08:14,437 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:08:14,437 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:08:14,438 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:08:15,135 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:08:15,135 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:08:17,615 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:08:17,615 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:08:17,856 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:08:22,856 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:08:26,271 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:08:26,272 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:08:26,272 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:08:26,272 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:08:27,138 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:08:27,138 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:08:28,272 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:08:32,615 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:08:32,616 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:08:33,751 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:08:38,144 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:08:38,144 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:08:38,144 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:08:38,144 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:08:39,140 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:08:39,140 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:08:39,145 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:08:43,937 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:08:44,937 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:08:47,615 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:08:47,616 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:08:49,974 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:08:49,974 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:08:49,975 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:08:49,975 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:08:49,976 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:08:50,142 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:08:51,143 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:08:54,976 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:08:59,977 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:09:01,800 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:09:01,801 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:09:01,801 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:09:01,801 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:09:02,145 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:09:02,615 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:09:02,616 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:09:03,145 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:09:05,810 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:09:10,811 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:09:13,639 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:09:13,640 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:09:13,640 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:09:13,640 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:09:13,937 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:09:14,147 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:09:15,148 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:09:15,938 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:09:17,616 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:09:17,616 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:09:21,768 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:09:25,515 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:09:25,516 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:09:25,516 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:09:25,517 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:09:26,150 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:09:27,150 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:09:27,517 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:09:32,518 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:09:32,616 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:09:32,616 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:09:37,368 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:09:37,368 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:09:37,369 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:09:37,369 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:09:38,153 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:09:38,369 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:09:39,153 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:09:43,370 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:09:43,938 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:09:47,616 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:09:47,616 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:09:48,834 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:09:49,212 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:09:49,213 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:09:49,213 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:09:49,213 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:09:50,156 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:09:51,156 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:09:54,214 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:09:59,214 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:10:01,055 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:10:01,056 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:10:01,056 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:10:01,057 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:10:01,159 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:10:02,616 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:10:02,616 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:10:03,159 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:10:04,771 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:10:09,772 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:10:12,920 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:10:12,920 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:10:12,920 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:10:12,921 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:10:13,161 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:10:13,938 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:10:14,939 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:10:15,162 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:10:17,616 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:10:17,616 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:10:20,832 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:10:24,751 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:10:24,752 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:10:24,752 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:10:24,752 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:10:25,164 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:10:26,753 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:10:27,165 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:10:31,753 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:10:32,616 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:10:32,617 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:10:36,613 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:10:36,614 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:10:36,614 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:10:36,615 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:10:37,167 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:10:37,167 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:10:37,615 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:10:42,616 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:10:43,939 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:10:47,616 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:10:47,617 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:10:47,741 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:10:48,473 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:10:48,473 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:10:48,473 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:10:48,474 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:10:49,170 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:10:49,170 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:10:53,475 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:10:58,475 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:11:00,320 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:11:00,321 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:11:00,321 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:11:00,321 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:11:01,173 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:11:01,173 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:11:02,616 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:11:02,617 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:11:03,803 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:11:08,804 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:11:12,166 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:11:12,166 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:11:12,167 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:11:12,168 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:11:12,176 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:11:13,176 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:11:13,939 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:11:13,940 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:11:17,617 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:11:17,617 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:11:19,778 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:11:24,001 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:11:24,002 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:11:24,002 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:11:24,003 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:11:24,178 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:11:25,003 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:11:25,179 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:11:30,004 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:11:32,617 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:11:32,617 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:11:35,795 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:11:35,843 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:11:35,843 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:11:35,844 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:11:35,844 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:11:36,181 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:11:37,182 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:11:40,845 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:11:43,940 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:11:45,940 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:11:47,617 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:11:47,617 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:11:47,687 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:11:47,827 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:11:47,827 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:11:47,827 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:11:48,184 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:11:49,184 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:11:51,828 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:11:56,829 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:11:59,523 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:11:59,523 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:11:59,524 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:11:59,524 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:12:00,187 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:12:01,187 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:12:02,525 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:12:02,617 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:12:02,617 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:12:07,778 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:12:11,357 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:12:11,358 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:12:11,358 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:12:11,358 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:12:12,190 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:12:13,190 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:12:13,359 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:12:13,940 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:12:17,617 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:12:17,617 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:12:18,782 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:12:23,204 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:12:23,205 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:12:23,205 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:12:23,205 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:12:24,193 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:12:24,206 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:12:25,193 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:12:29,206 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:12:32,617 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:12:32,618 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:12:34,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:12:35,053 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:12:35,054 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:12:35,054 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:12:35,054 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:12:35,196 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:12:37,196 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:12:40,055 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:12:43,941 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:12:45,941 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:12:46,908 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:12:46,908 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:12:46,908 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:12:46,909 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:12:47,198 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:12:47,617 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:12:47,618 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:12:49,199 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:12:51,849 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:12:56,849 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:12:58,749 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:12:58,750 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:12:58,750 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:12:58,750 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:12:59,201 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:12:59,202 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:13:02,617 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:13:02,618 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:13:02,796 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:13:07,797 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:13:10,583 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:13:10,584 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:13:10,584 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:13:10,584 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:13:11,204 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:13:11,204 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:13:13,585 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:13:13,945 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:13:17,618 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:13:17,618 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:13:18,772 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:13:22,425 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:13:22,425 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:13:22,426 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:13:22,426 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:13:23,207 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:13:23,207 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:13:24,426 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:13:29,427 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:13:32,618 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:13:32,618 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:13:34,269 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:13:34,269 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:13:34,270 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:13:34,270 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:13:35,210 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:13:35,210 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:13:35,270 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:13:40,271 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:13:43,942 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:13:45,942 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:13:46,083 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:13:46,083 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:13:46,084 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:13:46,085 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:13:46,213 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:13:47,213 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:13:47,618 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:13:47,618 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:13:51,751 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:13:56,751 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:13:57,949 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:13:57,950 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:13:57,950 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:13:57,950 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:13:58,216 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:13:59,216 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:14:01,951 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:14:02,618 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:14:02,618 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:14:07,824 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:14:09,783 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:14:09,784 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:14:09,784 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:14:09,784 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:14:10,219 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:14:11,219 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:14:13,785 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:14:13,942 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:14:17,618 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:14:17,619 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:14:19,771 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:14:21,638 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:14:21,639 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:14:21,639 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:14:21,640 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:14:22,222 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:14:23,222 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:14:25,641 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:14:30,641 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:14:32,618 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:14:32,619 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:14:33,513 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:14:33,514 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:14:33,514 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:14:33,515 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:14:34,225 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:14:35,225 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:14:36,515 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:14:41,516 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:14:43,943 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:14:45,391 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:14:45,391 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:14:45,392 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:14:45,392 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:14:46,228 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:14:47,228 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:14:47,392 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:14:47,618 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:14:47,619 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:14:52,782 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:14:57,232 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:14:57,232 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:14:57,233 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:14:57,233 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:14:58,230 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:14:58,234 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:14:59,231 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:15:02,618 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:15:02,619 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:15:03,827 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:15:08,827 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:15:09,081 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:15:09,082 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:15:09,082 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:15:09,082 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:15:09,233 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:15:11,233 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:15:13,943 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:15:13,944 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:15:17,619 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:15:17,619 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:15:19,786 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:15:20,916 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:15:20,916 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:15:20,917 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:15:20,917 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:15:21,236 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:15:21,236 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:15:24,918 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:15:29,918 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:15:32,619 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:15:32,619 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:15:32,775 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:15:32,841 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:15:32,842 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:15:32,843 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:15:33,239 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:15:33,239 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:15:35,844 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:15:40,844 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:15:43,944 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:15:44,623 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:15:44,624 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:15:44,624 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:15:44,624 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:15:45,242 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:15:45,242 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:15:46,625 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:15:47,619 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:15:47,619 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:15:51,777 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:15:56,485 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:15:56,486 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:15:56,486 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:15:56,486 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:15:57,245 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:15:57,245 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:15:57,486 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:16:02,487 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:16:02,619 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:16:02,619 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:16:07,828 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:16:08,326 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:16:08,326 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:16:08,326 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:16:08,327 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:16:09,248 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:16:09,249 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:16:13,328 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:16:13,944 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:16:17,619 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:16:17,619 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:16:18,805 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:16:20,164 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:16:20,164 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:16:20,165 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:16:20,165 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:16:20,251 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:16:21,251 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:16:24,165 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:16:29,166 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:16:32,018 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:16:32,019 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:16:32,019 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:16:32,019 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:16:32,254 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:16:32,619 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:16:32,619 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:16:33,254 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:16:34,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:16:39,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:16:43,871 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:16:43,872 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:16:43,872 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:16:43,873 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:16:43,945 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:16:44,256 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:16:44,945 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:16:45,257 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:16:47,619 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:16:47,620 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:16:50,851 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:16:55,721 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:16:55,722 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:16:55,722 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:16:55,722 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:16:56,259 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:16:56,722 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:16:57,259 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:17:01,723 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:17:02,619 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:17:02,620 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:17:06,850 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:17:07,640 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:17:07,641 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:17:07,641 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:17:07,641 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:17:08,262 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:17:09,262 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:17:12,642 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:17:13,945 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:17:17,620 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:17:17,620 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:17:17,849 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:17:19,500 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:17:19,500 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:17:19,500 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:17:19,501 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:17:20,265 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:17:21,265 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:17:23,501 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:17:28,502 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:17:31,339 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:17:31,340 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:17:31,340 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:17:31,340 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:17:32,268 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:17:32,620 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:17:32,620 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:17:33,761 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:17:34,268 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:17:38,762 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:17:43,182 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:17:43,183 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:17:43,183 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:17:43,183 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:17:43,270 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:17:43,946 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:17:43,947 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:17:44,271 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:17:47,620 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:17:47,620 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:17:49,815 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:17:54,816 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:17:55,059 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:17:55,060 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:17:55,060 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:17:55,060 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:17:55,273 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:17:56,273 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:18:00,061 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:18:02,620 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:18:02,620 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:18:05,788 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:18:06,907 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:18:06,908 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:18:06,908 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:18:06,908 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:18:07,276 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:18:08,276 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:18:10,909 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:18:13,954 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:18:15,955 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:18:17,620 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:18:17,620 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:18:18,746 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:18:18,746 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:18:18,746 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:18:18,747 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:18:19,278 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:18:20,279 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:18:21,747 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:18:26,748 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:18:30,616 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:18:30,617 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:18:30,617 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:18:30,617 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:18:31,281 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:18:32,281 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:18:32,618 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:18:32,620 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:18:32,620 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:18:37,840 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:18:42,474 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:18:42,475 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:18:42,475 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:18:42,475 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:18:43,284 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:18:43,476 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:18:43,947 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:18:44,284 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:18:47,620 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:18:47,620 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:18:48,841 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:18:53,842 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:18:58,287 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:18:59,223 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:19:02,620 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:19:02,621 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:19:04,821 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:19:08,929 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:19:08,929 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:19:08,929 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:19:09,069 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:19:09,289 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:19:10,070 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:19:10,290 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:19:13,947 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:19:15,948 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:19:17,620 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:19:17,621 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:19:20,737 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:19:20,737 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:19:20,737 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:19:20,738 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:19:21,292 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:19:21,738 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:19:22,292 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:19:26,739 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:19:31,739 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:19:32,550 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:19:32,551 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:19:32,551 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:19:32,552 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:19:32,620 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:19:32,621 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:19:33,295 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:19:34,295 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:19:36,839 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:19:41,840 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:19:43,948 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:19:44,389 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:19:44,390 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:19:44,390 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:19:44,390 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:19:45,298 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:19:46,298 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:19:47,391 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:19:47,621 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:19:47,621 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:19:52,856 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:19:56,237 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:19:56,237 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:19:56,237 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:19:56,238 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:19:56,300 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:19:58,238 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:19:58,301 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:20:02,621 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:20:02,621 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:20:03,760 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:20:08,138 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:20:08,139 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:20:08,139 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:20:08,140 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:20:08,303 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:20:09,140 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:20:10,304 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:20:13,948 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:20:14,949 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:20:19,950 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:20:20,438 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:20:20,438 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:20:25,610 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:20:29,210 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:20:29,211 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:20:29,211 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:20:29,211 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:20:29,308 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:20:30,308 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:20:31,211 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:20:35,438 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:20:35,438 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:20:36,579 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:20:40,998 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:20:40,998 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:20:40,999 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:20:41,000 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:20:41,310 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:20:42,000 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:20:42,311 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:20:43,949 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:20:47,950 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:20:50,438 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:20:50,438 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:20:52,834 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:20:52,834 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:20:52,835 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:20:52,835 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:20:53,313 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:20:53,835 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:20:54,313 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:20:58,836 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:21:03,837 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:21:04,660 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:21:04,661 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:21:04,661 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:21:04,661 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:21:05,316 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:21:05,438 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:21:05,439 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:21:06,316 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:21:09,609 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:21:13,949 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:21:14,950 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:21:16,526 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:21:16,526 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:21:16,527 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:21:16,527 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:21:17,319 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:21:18,319 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:21:20,438 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:21:20,438 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:21:20,439 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:21:25,605 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:21:28,374 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:21:28,374 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:21:28,375 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:21:28,375 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:21:29,321 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:21:30,322 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:21:31,375 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:21:35,438 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:21:35,438 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:21:36,664 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:21:40,230 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:21:40,230 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:21:40,231 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:21:40,231 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:21:40,324 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:21:42,231 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:21:42,325 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:21:43,950 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:21:47,951 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:21:50,438 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:21:50,439 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:21:52,062 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:21:52,062 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:21:52,063 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:21:52,063 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:21:52,327 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:21:53,063 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:21:54,327 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:21:58,064 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:22:03,064 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:22:03,842 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:22:03,842 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:22:03,843 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:22:03,843 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:22:04,330 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:22:05,438 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:22:05,439 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:22:06,330 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:22:08,677 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:22:13,678 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:22:13,950 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:22:15,742 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:22:15,742 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:22:15,743 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:22:15,743 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:22:16,332 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:22:18,333 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:22:18,743 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:22:20,439 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:22:20,439 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:22:24,672 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:22:27,574 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:22:27,574 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:22:27,575 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:22:27,575 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:22:28,335 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:22:30,336 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:22:30,575 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:22:35,439 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:22:35,439 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:22:35,666 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:22:39,438 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:22:39,438 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:22:39,439 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:22:39,439 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:22:40,338 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:22:40,338 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:22:41,439 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:22:43,951 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:22:46,952 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:22:50,439 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:22:50,439 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:22:51,294 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:22:51,294 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:22:51,295 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:22:51,295 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:22:51,340 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:22:52,295 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:22:52,341 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:22:57,296 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:23:02,297 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:23:03,092 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:23:03,092 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:23:03,093 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:23:03,093 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:23:03,343 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:23:04,343 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:23:05,439 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:23:05,439 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:23:07,651 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:23:12,652 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:23:13,955 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:23:14,986 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:23:14,986 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:23:14,987 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:23:14,987 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:23:15,346 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:23:16,346 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:23:17,987 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:23:20,439 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:23:20,439 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:23:23,621 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:23:26,830 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:23:26,830 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:23:26,831 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:23:26,831 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:23:27,348 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:23:28,349 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:23:28,831 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:23:33,832 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:23:35,439 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:23:35,439 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:23:38,694 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:23:38,694 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:23:38,695 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:23:38,695 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:23:39,351 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:23:39,695 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:23:40,351 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:23:43,952 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:23:44,953 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:23:49,953 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:23:50,439 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:23:50,440 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:23:50,550 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:23:50,610 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:23:50,610 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:23:50,611 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:23:51,354 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:23:52,354 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:23:55,612 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:24:00,612 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:24:02,362 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:24:02,363 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:24:02,363 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:24:02,363 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:24:03,356 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:24:04,357 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:24:05,439 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:24:05,440 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:24:06,572 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:24:11,572 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:24:13,952 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:24:14,270 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:24:14,270 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:24:14,271 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:24:14,271 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:24:14,359 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:24:16,360 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:24:17,271 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:24:20,439 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:24:20,440 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:24:22,568 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:24:26,118 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:24:26,118 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:24:26,119 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:24:26,119 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:24:26,362 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:24:28,120 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:24:28,362 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:24:33,121 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:24:35,439 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:24:35,440 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:24:37,962 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:24:37,963 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:24:37,963 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:24:37,963 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:24:38,365 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:24:38,963 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:24:40,365 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:24:43,953 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:24:44,953 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:24:49,773 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:24:49,774 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:24:49,774 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:24:49,775 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:24:50,367 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:24:50,439 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:24:50,440 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:24:50,440 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:24:52,368 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:24:55,588 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:25:00,589 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:25:01,682 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:25:01,683 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:25:01,683 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:25:01,684 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:25:02,370 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:25:02,370 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:25:05,440 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:25:05,440 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:25:05,673 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:25:10,674 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:25:13,538 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:25:13,539 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:25:13,539 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:25:13,539 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:25:13,953 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:25:14,373 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:25:14,373 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:25:15,954 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:25:20,440 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:25:20,440 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:25:21,620 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:25:25,418 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:25:25,418 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:25:25,419 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:25:25,419 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:25:26,375 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:25:26,376 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:25:27,420 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:25:32,420 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:25:35,440 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:25:35,440 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:25:37,270 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:25:37,271 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:25:37,271 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:25:37,273 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:25:37,378 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:25:38,273 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:25:38,378 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:25:43,274 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:25:43,954 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:25:48,955 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:25:49,095 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:25:49,095 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:25:49,096 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:25:49,096 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:25:49,381 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:25:50,381 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:25:50,440 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:25:50,440 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:25:54,653 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:25:59,654 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:26:00,978 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:26:00,978 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:26:00,979 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:26:00,979 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:26:01,383 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:26:02,384 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:26:04,980 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:26:05,440 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:26:05,441 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:26:10,585 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:26:12,918 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:26:12,919 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:26:12,919 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:26:12,920 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:26:13,386 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:26:13,954 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:26:14,386 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:26:15,955 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:26:20,441 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:26:20,441 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:26:21,660 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:26:24,778 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:26:24,779 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:26:24,779 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:26:24,779 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:26:25,389 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:26:26,389 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:26:26,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:26:31,780 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:26:35,440 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:26:35,441 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:26:36,642 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:26:36,642 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:26:36,643 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:26:36,643 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:26:37,392 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:26:37,643 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:26:38,392 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:26:42,644 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:26:43,955 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:26:47,956 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:26:48,443 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:26:48,444 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:26:48,444 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:26:48,445 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:26:49,395 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:26:50,395 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:26:50,440 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:26:50,441 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:26:53,603 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:26:58,604 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:27:00,334 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:27:00,334 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:27:00,335 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:27:00,335 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:27:00,397 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:27:02,398 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:27:04,336 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:27:05,441 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:27:05,441 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:27:09,678 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:27:12,166 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:27:12,166 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:27:12,167 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:27:12,167 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:27:12,400 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:27:13,955 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:27:14,401 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:27:14,956 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:27:19,957 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:27:20,441 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:27:20,441 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:27:24,030 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:27:24,031 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:27:24,031 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:27:24,031 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:27:24,403 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:27:25,031 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:27:26,404 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:27:30,032 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:27:35,033 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:27:35,441 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:27:35,441 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:27:35,890 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:27:35,891 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:27:35,891 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:27:35,891 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:27:36,406 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:27:36,406 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:27:40,892 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:27:43,956 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:27:45,957 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:27:47,694 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:27:47,695 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:27:47,695 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:27:47,695 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:27:48,409 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:27:48,409 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:27:50,441 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:27:50,441 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:27:51,661 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:27:56,662 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:27:59,578 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:27:59,578 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:27:59,579 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:27:59,579 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:28:00,412 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:28:00,413 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:28:02,580 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:28:05,441 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:28:05,441 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:28:07,630 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:28:11,414 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:28:11,414 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:28:11,415 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:28:11,415 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:28:11,415 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:28:12,416 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:28:13,415 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:28:13,956 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:28:18,957 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:28:20,441 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:28:20,441 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:28:23,274 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:28:23,274 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:28:23,275 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:28:23,275 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:28:23,418 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:28:24,275 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:28:24,419 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:28:29,276 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:28:34,277 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:28:35,071 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:28:35,072 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:28:35,072 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:28:35,072 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:28:35,421 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:28:35,441 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:28:35,442 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:28:36,422 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:28:39,610 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:28:43,957 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:28:44,957 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:28:46,958 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:28:46,958 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:28:46,959 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:28:46,959 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:28:47,424 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:28:48,425 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:28:49,960 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:28:50,441 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:28:50,442 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:28:55,661 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:28:58,810 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:28:58,810 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:28:58,811 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:28:58,811 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:28:59,427 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:29:00,428 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:29:00,811 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:29:05,441 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:29:05,442 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:29:06,634 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:29:10,670 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:29:10,670 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:29:10,671 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:29:10,671 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:29:11,430 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:29:11,671 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:29:12,431 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:29:13,957 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:29:16,958 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:29:20,441 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:29:20,442 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:29:22,476 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:29:22,518 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:29:22,518 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:29:22,519 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:29:22,519 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:29:23,433 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:29:24,434 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:29:27,520 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:29:32,520 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:29:34,308 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:29:34,309 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:29:34,309 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:29:34,309 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:29:34,436 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:29:35,442 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:29:35,442 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:29:36,437 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:29:37,640 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:29:42,641 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:29:43,958 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:29:46,190 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:29:46,190 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:29:46,191 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:29:46,191 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:29:46,439 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:29:48,191 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:29:48,440 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:29:50,442 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:29:50,442 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:29:53,677 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:29:58,050 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:29:58,050 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:29:58,051 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:29:58,051 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:29:58,442 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:29:58,442 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:29:59,051 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:30:04,052 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:30:05,442 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:30:05,442 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:30:09,623 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:30:09,890 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:30:09,890 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:30:09,891 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:30:09,891 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:30:10,445 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:30:10,445 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:30:13,958 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:30:14,959 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:30:19,960 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:30:20,442 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:30:20,442 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:30:21,762 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:30:21,762 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:30:21,763 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:30:21,763 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:30:22,449 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:30:22,449 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:30:25,763 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:30:30,764 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:30:33,580 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:30:33,581 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:30:33,581 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:30:33,581 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:30:34,452 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:30:34,452 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:30:35,442 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:30:35,442 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:30:36,661 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:30:41,662 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:30:43,959 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:30:45,454 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:30:45,455 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:30:45,455 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:30:45,455 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:30:45,455 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:30:46,455 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:30:47,456 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:30:50,442 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:30:50,442 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:30:52,662 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:30:57,314 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:30:57,314 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:30:57,315 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:30:57,315 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:30:57,458 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:30:58,315 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:30:58,458 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:31:03,316 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:31:05,442 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:31:05,443 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:31:08,633 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:31:09,162 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:31:09,162 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:31:09,163 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:31:09,163 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:31:09,461 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:31:10,461 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:31:13,959 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:31:13,960 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:31:18,961 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:31:20,442 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:31:20,443 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:31:20,994 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:31:20,994 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:31:20,995 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:31:20,995 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:31:21,463 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:31:22,464 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:31:23,995 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:31:28,996 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:31:32,790 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:31:32,790 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:31:32,791 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:31:32,791 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:31:33,466 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:31:34,466 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:31:34,791 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:31:35,442 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:31:35,443 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:31:40,596 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:31:43,960 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:31:44,662 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:31:44,662 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:31:44,663 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:31:44,663 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:31:45,469 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:31:45,663 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:31:46,469 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:31:50,442 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:31:50,443 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:31:51,594 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:31:56,486 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:31:56,486 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:31:56,487 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:31:56,487 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:31:57,471 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:31:57,487 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:31:58,472 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:32:02,488 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:32:05,443 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:32:05,443 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:32:07,586 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:32:08,306 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:32:08,306 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:32:08,307 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:32:08,307 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:32:08,474 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:32:10,474 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:32:13,307 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:32:13,960 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:32:18,961 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:32:20,090 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:32:20,091 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:32:20,091 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:32:20,091 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:32:20,443 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:32:20,443 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:32:20,476 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:32:20,476 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:32:24,592 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:32:29,593 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:32:31,962 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:32:31,962 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:32:31,963 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:32:31,963 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:32:32,479 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:32:32,479 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:32:34,963 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:32:35,443 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:32:35,443 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:32:40,627 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:32:43,794 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:32:43,794 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:32:43,795 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:32:43,795 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:32:43,961 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:32:44,482 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:32:44,482 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:32:45,962 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:32:50,443 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:32:50,444 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:32:51,615 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:32:55,662 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:32:55,666 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:32:55,666 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:32:55,666 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:32:56,485 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:32:56,485 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:32:56,667 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:33:01,667 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:33:05,443 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:33:05,444 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:33:07,465 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:33:07,506 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:33:07,506 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:33:07,507 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:33:07,507 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:33:08,488 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:33:08,488 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:33:12,508 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:33:13,962 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:33:17,962 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:33:19,298 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:33:19,299 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:33:19,299 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:33:19,299 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:33:19,491 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:33:20,443 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:33:20,444 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:33:20,491 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:33:23,615 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:33:28,616 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:33:31,178 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:33:31,178 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:33:31,179 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:33:31,179 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:33:31,494 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:33:33,494 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:33:34,179 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:33:35,444 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:33:35,444 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:33:39,579 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:33:43,034 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:33:43,035 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:33:43,035 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:33:43,035 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:33:43,497 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:33:43,962 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:33:44,963 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:33:45,497 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:33:49,963 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:33:50,444 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:33:50,444 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:33:54,878 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:33:54,878 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:33:54,879 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:33:54,879 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:33:55,500 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:33:55,879 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:33:57,500 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:34:00,880 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:34:05,444 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:34:05,444 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:34:06,645 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:34:06,742 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:34:06,742 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:34:06,743 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:34:06,743 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:34:07,502 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:34:09,503 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:34:11,744 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:34:13,963 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:34:16,963 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:34:18,554 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:34:18,555 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:34:18,555 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:34:18,555 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:34:19,506 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:34:20,444 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:34:20,444 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:34:21,506 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:34:22,620 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:34:27,621 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:34:30,450 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:34:30,450 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:34:30,451 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:34:30,451 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:34:30,508 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:34:33,451 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:34:33,509 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:34:35,444 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:34:35,444 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:34:38,631 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:34:42,370 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:34:42,371 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:34:42,371 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:34:42,371 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:34:42,512 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:34:43,512 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:34:43,963 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:34:43,964 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:34:48,964 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:34:50,444 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:34:50,445 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:34:54,166 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:34:54,206 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:34:54,206 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:34:54,207 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:34:54,207 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:34:54,515 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:34:55,515 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:34:59,208 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:35:04,208 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:35:05,444 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:35:05,445 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:35:06,046 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:35:06,047 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:35:06,047 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:35:06,047 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:35:06,518 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:35:07,518 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:35:10,048 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:35:13,964 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:35:15,964 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:35:17,835 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:35:17,835 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:35:17,836 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:35:17,836 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:35:18,521 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:35:19,521 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:35:20,444 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:35:20,445 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:35:21,594 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:35:26,595 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:35:29,746 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:35:29,747 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:35:29,747 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:35:29,747 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:35:30,524 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:35:31,524 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:35:31,748 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:35:35,445 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:35:35,445 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:35:37,671 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:35:41,578 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:35:41,579 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:35:41,579 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:35:41,579 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:35:42,527 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:35:43,528 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:35:43,580 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:35:43,964 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:35:48,965 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:35:50,445 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:35:50,445 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:35:53,406 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:35:53,407 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:35:53,407 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:35:53,407 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:35:53,530 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:35:54,408 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:35:55,531 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:35:59,408 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:36:04,409 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:36:05,182 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:36:05,182 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:36:05,183 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:36:05,183 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:36:05,445 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:36:05,445 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:36:05,533 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:36:07,534 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:36:09,600 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:36:13,965 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:36:14,965 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:36:17,058 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:36:17,059 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:36:17,059 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:36:17,059 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:36:17,537 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:36:19,537 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:36:20,060 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:36:20,445 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:36:20,445 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:36:25,606 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:36:28,926 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:36:28,927 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:36:28,927 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:36:28,927 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:36:29,540 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:36:30,928 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:36:31,540 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:36:35,445 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:36:35,445 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:36:36,588 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:36:40,770 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:36:40,771 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:36:40,771 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:36:40,771 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:36:41,543 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:36:41,771 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:36:43,544 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:36:43,965 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:36:46,966 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:36:50,445 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:36:50,446 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:36:52,582 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:36:52,626 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:36:52,626 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:36:52,627 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:36:52,627 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:36:53,546 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:36:55,547 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:36:57,628 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:37:02,628 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:37:04,435 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:37:04,436 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:37:04,436 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:37:04,436 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:37:04,549 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:37:05,445 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:37:05,445 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:37:05,550 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:37:08,595 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:37:13,596 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:37:13,966 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:37:16,314 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:37:16,315 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:37:16,315 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:37:16,315 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:37:16,552 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:37:17,553 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:37:19,316 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:37:20,445 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:37:20,446 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:37:24,577 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:37:28,142 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:37:28,143 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:37:28,143 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:37:28,143 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:37:28,555 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:37:29,556 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:37:30,144 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:37:35,144 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:37:35,446 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:37:35,446 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:37:39,978 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:37:39,979 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:37:39,979 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:37:39,979 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:37:40,558 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:37:40,979 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:37:41,559 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:37:43,966 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:37:46,967 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:37:50,446 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:37:50,446 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:37:51,822 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:37:51,823 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:37:51,823 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:37:51,823 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:37:52,561 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:37:52,823 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:37:53,562 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:37:57,824 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:38:02,825 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:38:03,612 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:38:03,612 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:38:03,613 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:38:03,613 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:38:04,564 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:38:05,446 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:38:05,446 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:38:05,565 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:38:08,650 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:38:13,651 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:38:13,966 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:38:15,486 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:38:15,487 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:38:15,487 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:38:15,487 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:38:15,567 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:38:17,568 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:38:19,488 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:38:20,446 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:38:20,446 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:38:24,622 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:38:27,370 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:38:27,371 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:38:27,371 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:38:27,371 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:38:27,570 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:38:29,571 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:38:30,372 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:38:35,372 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:38:35,446 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:38:35,446 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:38:39,214 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:38:39,215 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:38:39,215 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:38:39,215 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:38:39,573 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:38:41,216 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:38:41,574 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:38:43,967 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:38:46,968 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:38:50,446 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:38:50,446 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:38:51,050 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:38:51,051 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:38:51,051 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:38:51,051 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:38:51,577 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:38:52,051 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:38:53,577 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:38:57,052 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:39:02,053 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:39:05,447 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:39:05,447 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:39:07,581 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:39:07,589 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:39:12,590 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:39:13,968 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:39:17,079 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:39:17,080 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:39:17,080 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:39:17,188 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:39:17,584 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:39:18,190 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:39:19,585 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:39:20,446 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:39:20,446 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:39:23,581 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:39:28,581 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:39:28,863 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:39:28,864 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:39:28,864 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:39:28,864 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:39:29,587 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:39:31,587 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:39:33,865 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:39:35,446 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:39:35,447 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:39:39,626 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:39:40,687 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:39:40,687 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:39:40,688 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:39:40,688 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:39:41,590 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:39:41,590 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:39:43,968 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:39:44,969 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:39:49,969 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:39:50,446 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:39:50,447 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:39:52,566 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:39:52,567 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:39:52,567 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:39:52,567 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:39:52,593 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:39:53,594 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:39:55,568 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:40:00,568 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:40:04,367 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:40:04,368 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:40:04,368 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:40:04,368 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:40:04,597 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:40:05,447 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:40:05,447 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:40:05,597 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:40:05,600 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:40:10,601 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:40:13,969 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:40:15,969 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:40:16,218 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:40:16,219 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:40:16,219 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:40:16,219 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:40:16,600 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:40:17,601 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:40:20,447 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:40:20,447 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:40:21,676 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:40:26,677 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:40:28,081 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:40:28,081 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:40:28,082 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:40:28,082 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:40:28,604 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:40:29,604 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:40:32,083 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:40:35,447 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:40:35,448 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:40:37,666 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:40:39,920 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:40:39,921 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:40:39,921 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:40:39,921 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:40:40,607 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:40:41,607 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:40:42,922 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:40:43,969 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:40:47,970 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:40:50,447 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:40:50,447 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:40:51,774 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:40:51,775 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:40:51,775 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:40:51,775 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:40:52,610 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:40:53,611 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:40:53,775 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:40:58,776 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:41:03,614 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:41:03,615 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:41:03,615 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:41:03,615 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:41:04,613 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:41:04,615 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:41:05,447 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:41:05,447 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:41:05,614 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:41:09,620 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:41:13,970 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:41:14,970 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:41:15,459 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:41:15,460 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:41:15,460 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:41:15,460 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:41:15,616 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:41:17,617 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:41:20,447 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:41:20,447 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:41:20,447 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:41:25,654 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:41:27,307 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:41:27,308 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:41:27,308 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:41:27,308 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:41:27,619 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:41:29,620 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:41:31,309 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:41:35,448 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:41:35,448 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:41:36,661 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:41:39,162 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:41:39,162 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:41:39,162 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:41:39,162 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:41:39,623 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:41:41,623 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:41:42,163 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:41:43,970 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:41:47,971 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:41:50,448 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:41:50,448 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:41:51,016 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:41:51,017 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:41:51,017 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:41:51,017 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:41:51,626 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:41:53,018 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:41:53,626 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:41:58,018 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:42:02,880 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:42:02,880 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:42:02,881 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:42:02,881 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:42:03,628 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:42:03,881 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:42:05,448 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:42:05,448 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:42:05,629 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:42:09,607 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:42:13,971 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:42:14,725 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:42:14,725 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:42:14,725 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:42:14,726 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:42:14,726 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:42:15,631 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:42:15,631 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:42:19,727 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:42:20,448 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:42:20,448 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:42:25,681 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:42:26,561 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:42:26,562 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:42:26,562 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:42:26,562 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:42:26,634 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:42:27,634 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:42:31,563 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:42:35,448 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:42:35,448 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:42:36,631 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:42:38,373 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:42:38,373 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:42:38,373 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:42:38,374 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:42:38,637 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:42:39,637 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:42:42,374 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:42:43,971 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:42:47,972 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:42:50,215 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:42:50,219 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:42:50,219 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:42:50,219 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:42:50,448 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:42:50,448 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:42:50,639 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:42:51,640 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:42:53,593 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:42:58,594 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:43:02,044 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:43:02,045 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:43:02,045 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:43:02,045 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:43:02,642 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:43:03,643 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:43:04,046 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:43:05,448 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:43:05,448 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:43:09,639 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:43:13,888 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:43:13,889 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:43:13,889 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:43:13,889 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:43:13,972 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:43:14,645 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:43:14,972 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:43:15,645 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:43:19,973 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:43:20,448 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:43:20,448 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:43:25,626 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:43:25,732 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:43:25,733 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:43:25,733 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:43:25,733 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:43:26,648 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:43:27,648 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:43:30,734 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:43:35,448 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:43:35,449 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:43:36,683 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:43:37,573 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:43:37,574 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:43:37,574 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:43:37,574 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:43:37,651 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:43:39,651 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:43:42,575 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:43:43,972 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:43:47,973 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:43:49,407 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:43:49,407 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:43:49,408 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:43:49,408 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:43:49,654 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:43:50,449 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:43:50,449 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:43:51,655 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:43:53,671 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:43:58,671 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:44:01,264 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:44:01,264 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:44:01,265 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:44:01,265 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:44:01,657 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:44:03,658 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:44:04,265 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:44:05,449 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:44:05,449 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:44:09,671 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:44:13,108 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:44:13,109 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:44:13,109 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:44:13,109 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:44:13,661 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:44:13,973 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:44:14,973 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:44:15,661 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:44:19,974 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:44:20,449 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:44:20,449 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:44:24,954 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:44:24,955 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:44:24,955 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:44:24,955 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:44:25,664 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:44:25,664 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:44:25,956 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:44:30,956 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:44:35,957 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:44:38,281 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:44:38,282 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:44:41,501 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:44:43,973 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:44:46,974 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:44:49,542 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:44:49,542 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:44:49,543 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:44:49,543 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:44:49,670 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:44:51,670 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:44:52,544 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:44:53,281 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:44:53,281 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:44:58,431 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:45:01,358 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:45:01,358 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:45:01,359 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:45:01,359 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:45:01,673 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:45:03,673 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:45:04,359 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:45:08,281 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:45:08,281 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:45:09,501 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:45:13,190 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:45:13,190 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:45:13,191 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:45:13,191 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:45:13,676 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:45:13,974 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:45:14,974 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:45:15,676 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:45:19,975 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:45:23,281 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:45:23,281 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:45:24,985 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:45:25,026 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:45:25,026 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:45:25,027 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:45:25,027 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:45:25,679 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:45:25,679 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:45:30,028 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:45:35,028 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:45:36,836 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:45:36,836 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:45:36,837 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:45:36,837 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:45:37,682 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:45:37,682 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:45:38,281 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:45:38,281 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:45:40,414 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:45:43,974 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:45:45,975 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:45:48,714 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:45:48,714 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:45:48,715 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:45:48,715 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:45:49,684 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:45:49,685 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:45:51,716 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:45:53,281 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:45:53,282 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:45:57,478 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:46:00,558 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:46:00,558 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:46:00,559 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:46:00,559 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:46:00,687 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:46:01,688 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:46:02,559 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:46:07,560 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:46:08,281 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:46:08,282 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:46:12,406 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:46:12,406 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:46:12,407 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:46:12,407 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:46:12,690 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:46:13,407 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:46:13,691 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:46:13,975 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:46:18,976 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:46:23,281 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:46:23,282 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:46:24,208 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:46:24,250 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:46:24,250 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:46:24,251 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:46:24,251 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:46:24,693 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:46:25,694 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:46:29,252 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:46:34,252 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:46:36,093 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:46:36,094 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:46:36,094 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:46:36,094 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:46:36,696 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:46:37,696 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:46:38,281 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:46:38,282 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:46:39,441 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:46:43,975 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:46:44,976 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:46:47,998 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:46:47,998 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:46:47,999 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:46:47,999 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:46:48,699 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:46:49,699 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:46:49,999 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:46:53,282 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:46:53,282 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:46:55,510 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:46:59,842 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:46:59,842 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:46:59,843 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:46:59,843 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:47:00,702 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:47:00,843 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:47:01,703 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:47:05,844 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:47:08,282 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:47:08,282 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:47:11,419 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:47:11,690 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:47:11,691 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:47:11,691 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:47:11,691 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:47:11,705 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:47:13,706 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:47:13,976 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:47:16,977 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:47:21,977 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:47:23,282 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:47:23,282 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:47:23,558 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:47:23,558 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:47:23,559 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:47:23,559 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:47:23,708 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:47:25,709 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:47:27,560 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:47:32,560 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:47:35,349 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:47:35,349 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:47:35,350 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:47:35,350 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:47:35,711 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:47:37,712 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:47:38,282 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:47:38,282 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:47:38,282 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:47:43,463 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:47:43,976 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:47:47,266 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:47:47,270 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:47:47,271 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:47:47,271 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:47:47,714 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:47:47,715 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:47:49,271 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:47:53,282 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:47:53,282 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:47:54,414 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:47:59,110 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:47:59,110 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:47:59,111 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:47:59,111 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:47:59,717 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:47:59,717 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:48:00,111 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:48:05,112 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:48:08,282 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:48:08,283 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:48:10,414 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:48:10,934 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:48:10,934 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:48:10,935 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:48:10,935 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:48:11,720 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:48:11,720 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:48:13,977 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:48:15,978 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:48:20,978 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:48:22,746 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:48:22,747 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:48:22,747 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:48:22,747 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:48:23,282 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:48:23,283 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:48:23,723 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:48:23,723 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:48:26,527 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:48:31,528 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:48:34,658 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:48:34,659 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:48:34,659 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:48:34,659 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:48:34,726 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:48:35,726 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:48:36,659 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:48:38,283 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:48:38,283 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:48:42,494 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:48:43,977 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:48:46,502 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:48:46,502 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:48:46,503 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:48:46,503 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:48:46,728 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:48:47,503 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:48:47,729 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:48:52,504 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:48:53,283 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:48:53,283 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:48:58,313 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:48:58,354 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:48:58,354 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:48:58,355 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:48:58,355 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:48:58,731 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:48:59,732 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:49:03,356 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:49:08,283 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:49:08,283 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:49:08,442 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:49:10,198 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:49:10,198 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:49:10,199 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:49:10,199 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:49:10,734 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:49:11,735 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:49:13,978 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:49:13,978 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:49:18,979 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:49:22,004 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:49:22,004 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:49:22,004 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:49:22,005 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:49:22,737 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:49:23,283 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:49:23,283 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:49:23,738 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:49:24,493 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:49:29,494 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:49:33,882 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:49:33,882 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:49:33,883 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:49:33,883 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:49:34,740 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:49:34,883 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:49:35,741 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:49:38,283 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:49:38,283 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:49:40,487 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:49:43,978 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:49:45,667 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:49:45,710 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:49:45,710 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:49:45,711 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:49:45,711 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:49:45,743 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:49:47,744 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:49:50,712 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:49:53,283 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:49:53,283 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:49:56,516 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:49:57,513 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:49:57,514 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:49:57,514 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:49:57,514 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:49:57,746 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:49:59,747 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:50:02,515 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:50:07,516 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:50:08,283 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:50:08,283 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:50:09,414 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:50:09,415 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:50:09,415 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:50:09,415 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:50:09,749 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:50:09,749 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:50:13,416 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:50:13,979 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:50:18,980 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:50:21,247 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:50:21,247 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:50:21,248 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:50:21,248 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:50:21,752 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:50:21,752 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:50:23,283 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:50:23,283 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:50:24,496 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:50:29,497 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:50:33,118 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:50:33,118 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:50:33,119 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:50:33,119 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:50:33,755 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:50:33,755 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:50:35,120 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:50:38,283 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:50:38,284 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:50:40,486 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:50:43,980 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:50:44,990 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:50:44,990 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:50:44,991 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:50:44,991 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:50:45,759 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:50:45,759 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:50:45,991 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:50:50,992 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:50:53,283 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:50:53,284 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:50:56,521 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:50:56,826 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:50:56,826 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:50:56,827 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:50:56,827 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:50:57,762 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:50:57,762 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:51:01,828 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:51:06,828 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:51:08,284 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:51:08,284 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:51:08,658 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:51:08,658 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:51:08,659 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:51:08,659 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:51:08,765 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:51:09,765 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:51:12,660 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:51:13,980 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:51:17,981 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:51:20,469 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:51:20,470 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:51:20,470 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:51:20,470 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:51:20,767 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:51:22,768 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:51:23,284 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:51:23,284 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:51:23,284 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:51:28,412 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:51:32,382 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:51:32,383 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:51:32,383 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:51:32,383 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:51:32,770 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:51:34,384 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:51:34,771 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:51:38,284 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:51:38,284 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:51:39,514 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:51:43,981 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:51:44,234 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:51:44,234 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:51:44,235 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:51:44,235 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:51:44,773 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:51:45,235 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:51:46,773 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:51:50,236 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:51:53,284 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:51:53,284 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:51:55,519 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:51:56,094 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:51:56,094 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:51:56,095 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:51:56,095 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:51:56,776 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:51:58,776 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:52:01,096 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:52:06,097 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:52:07,899 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:52:07,900 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:52:07,900 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:52:07,900 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:52:08,285 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:52:08,285 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:52:08,779 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:52:10,779 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:52:11,467 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:52:13,981 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:52:16,982 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:52:19,801 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:52:19,802 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:52:19,802 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:52:19,803 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:52:20,782 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:52:22,782 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:52:22,803 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:52:23,284 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:52:23,285 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:52:28,429 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:52:31,702 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:52:31,703 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:52:31,703 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:52:31,703 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:52:31,785 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:52:33,704 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:52:34,785 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:52:38,285 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:52:38,285 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:52:39,459 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:52:43,598 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:52:43,598 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:52:43,599 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:52:43,599 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:52:43,788 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:52:43,986 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:52:44,788 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:52:44,987 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:52:49,987 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:52:53,285 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:52:53,285 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:52:55,435 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:52:55,478 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:52:55,478 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:52:55,479 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:52:55,479 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:52:55,791 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:52:56,791 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:53:00,480 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:53:05,481 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:53:07,309 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:53:07,310 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:53:07,310 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:53:07,311 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:53:07,794 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:53:08,285 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:53:08,285 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:53:08,794 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:53:11,480 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:53:13,982 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:53:16,983 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:53:19,230 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:53:19,230 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:53:19,231 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:53:19,232 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:53:19,797 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:53:20,797 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:53:22,232 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:53:23,285 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:53:23,285 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:53:27,450 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:53:31,070 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:53:31,071 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:53:31,071 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:53:31,071 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:53:31,800 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:53:32,800 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:53:33,072 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:53:38,072 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:53:38,285 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:53:38,285 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:53:42,914 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:53:42,915 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:53:42,915 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:53:42,915 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:53:43,803 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:53:43,915 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:53:43,983 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:53:44,804 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:53:48,984 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:53:53,285 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:53:53,286 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:53:54,429 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:53:54,762 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:53:54,762 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:53:54,763 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:53:54,764 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:53:54,806 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:53:56,807 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:53:59,765 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:54:04,765 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:54:06,628 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:54:06,629 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:54:06,629 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:54:06,629 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:54:06,809 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:54:08,285 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:54:08,286 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:54:08,810 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:54:10,471 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:54:13,983 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:54:15,984 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:54:18,538 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:54:18,539 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:54:18,539 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:54:18,539 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:54:18,813 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:54:20,813 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:54:21,540 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:54:23,285 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:54:23,286 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:54:27,525 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:54:30,398 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:54:30,399 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:54:30,399 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:54:30,400 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:54:30,816 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:54:32,816 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:54:33,400 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:54:38,285 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:54:38,286 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:54:38,501 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:54:42,250 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:54:42,251 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:54:42,251 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:54:42,251 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:54:42,819 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:54:43,984 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:54:43,984 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:54:44,820 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:54:48,985 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:54:53,285 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:54:53,286 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:54:54,056 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:54:54,098 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:54:54,098 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:54:54,099 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:54:54,099 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:54:54,822 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:54:56,823 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:54:59,100 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:55:04,100 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:55:05,913 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:55:05,914 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:55:05,914 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:55:05,915 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:55:06,825 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:55:08,286 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:55:08,286 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:55:08,826 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:55:09,476 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:55:13,984 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:55:14,985 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:55:17,818 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:55:17,819 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:55:17,819 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:55:17,819 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:55:17,828 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:55:20,819 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:55:20,829 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:55:23,286 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:55:23,286 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:55:26,503 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:55:29,702 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:55:29,703 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:55:29,703 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:55:29,703 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:55:29,832 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:55:30,832 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:55:31,703 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:55:36,704 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:55:38,286 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:55:38,286 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:55:41,562 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:55:41,562 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:55:41,563 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:55:41,564 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:55:41,835 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:55:42,564 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:55:42,835 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:55:43,985 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:55:47,986 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:55:52,986 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:55:53,286 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:55:53,286 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:55:53,406 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:55:53,522 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:55:53,523 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:55:53,523 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:55:53,838 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:55:54,838 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:55:58,524 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:56:03,525 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:56:05,210 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:56:05,211 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:56:05,211 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:56:05,211 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:56:05,841 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:56:06,841 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:56:08,286 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:56:08,287 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:56:09,431 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:56:13,985 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:56:14,986 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:56:17,074 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:56:17,074 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:56:17,075 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:56:17,075 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:56:17,843 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:56:18,844 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:56:20,075 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:56:23,286 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:56:23,287 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:56:25,452 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:56:28,922 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:56:28,922 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:56:28,923 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:56:28,923 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:56:29,846 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:56:30,847 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:56:30,923 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:56:35,924 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:56:38,286 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:56:38,287 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:56:40,778 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:56:40,778 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:56:40,779 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:56:40,779 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:56:40,849 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:56:41,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:56:42,850 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:56:43,986 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:56:46,987 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:56:51,987 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:56:52,583 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:56:52,583 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:56:52,583 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:56:52,584 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:56:52,852 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:56:53,286 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:56:53,287 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:56:54,853 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:56:57,521 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:57:02,522 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:57:04,462 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:57:04,462 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:57:04,463 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:57:04,463 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:57:04,856 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:57:06,856 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:57:08,287 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:57:08,287 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:57:08,287 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:57:13,439 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:57:13,986 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:57:16,306 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:57:16,306 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:57:16,307 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:57:16,307 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:57:16,859 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:57:18,860 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:57:19,307 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:57:23,287 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:57:23,287 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:57:24,440 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:57:28,198 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:57:28,198 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:57:28,199 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:57:28,199 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:57:28,862 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:57:30,199 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:57:30,863 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:57:35,200 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:57:38,287 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:57:38,287 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:57:40,050 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:57:40,050 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:57:40,051 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:57:40,051 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:57:40,865 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:57:41,051 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:57:42,866 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:57:43,991 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:57:46,991 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:57:51,866 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:57:51,867 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:57:51,867 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:57:51,867 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:57:51,868 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:57:52,868 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:57:52,868 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:57:53,287 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:57:53,287 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:57:58,510 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:58:03,511 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:58:03,754 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:58:03,754 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:58:03,755 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:58:03,755 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:58:03,871 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:58:04,871 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:58:08,287 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:58:08,287 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:58:09,480 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:58:13,987 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:58:14,988 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:58:15,598 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:58:15,598 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:58:15,599 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:58:15,600 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:58:15,874 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:58:16,874 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:58:20,600 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:58:23,287 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:58:23,288 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:58:26,478 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:58:27,474 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:58:27,474 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:58:27,475 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:58:27,475 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:58:27,877 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:58:28,878 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:58:32,476 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:58:37,476 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:58:38,287 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:58:38,288 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:58:39,318 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:58:39,318 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:58:39,319 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:58:39,319 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:58:39,880 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:58:40,881 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:58:43,319 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:58:43,988 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:58:48,988 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:58:51,156 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:58:51,157 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:58:51,157 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:58:51,158 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:58:51,883 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:58:52,884 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:58:53,287 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:58:53,288 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:58:54,432 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:58:59,433 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:59:03,066 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:59:03,066 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:59:03,067 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:59:03,067 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:59:03,886 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:59:04,887 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:59:05,067 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:59:08,287 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:59:08,288 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:59:10,477 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:59:13,988 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:59:15,989 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:59:18,890 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:59:21,387 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:59:23,288 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:59:23,288 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:59:26,419 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:59:29,098 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:59:29,099 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:59:29,099 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:59:29,236 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:59:29,892 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:59:30,893 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:59:32,237 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:59:37,238 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:59:38,288 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:59:38,288 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:59:40,906 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:59:40,906 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:59:40,907 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:59:40,907 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:59:41,895 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:59:42,896 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:59:42,907 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:59:43,989 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 22:59:47,990 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:59:52,687 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 22:59:52,687 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 22:59:52,688 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 22:59:52,688 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 22:59:52,898 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 22:59:53,288 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 22:59:53,288 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 22:59:53,288 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 22:59:54,899 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 22:59:58,454 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:00:03,455 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:00:04,562 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:00:04,562 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:00:04,563 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:00:04,564 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:00:04,902 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:00:06,902 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:00:08,288 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:00:08,288 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:00:09,444 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:00:13,989 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:00:14,990 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:00:16,406 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:00:16,406 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:00:16,407 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:00:16,407 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:00:16,905 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:00:18,906 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:00:20,407 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:00:23,288 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:00:23,288 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:00:25,514 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:00:28,246 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:00:28,246 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:00:28,247 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:00:28,247 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:00:28,908 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:00:30,909 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:00:31,247 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:00:36,248 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:00:38,288 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:00:38,288 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:00:40,102 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:00:40,102 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:00:40,103 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:00:40,104 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:00:40,912 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:00:40,912 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:00:42,104 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:00:43,990 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:00:47,991 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:00:51,908 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:00:51,908 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:00:51,909 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:00:51,909 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:00:51,915 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:00:52,915 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:00:53,288 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:00:53,289 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:00:53,289 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:00:58,412 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:01:03,413 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:01:03,806 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:01:03,806 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:01:03,807 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:01:03,807 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:01:03,917 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:01:04,918 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:01:08,288 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:01:08,289 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:01:08,481 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:01:13,482 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:01:13,990 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:01:15,674 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:01:15,674 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:01:15,675 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:01:15,675 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:01:15,920 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:01:16,921 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:01:18,675 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:01:23,288 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:01:23,289 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:01:24,520 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:01:27,510 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:01:27,510 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:01:27,511 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:01:27,511 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:01:27,923 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:01:28,924 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:01:30,511 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:01:35,512 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:01:38,289 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:01:38,289 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:01:39,350 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:01:39,350 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:01:39,351 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:01:39,351 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:01:39,926 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:01:40,926 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:01:41,351 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:01:43,991 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:01:46,992 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:01:51,161 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:01:51,161 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:01:51,162 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:01:51,162 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:01:51,929 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:01:52,162 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:01:52,929 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:01:53,289 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:01:53,289 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:01:57,517 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:02:02,518 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:02:03,058 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:02:03,058 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:02:03,059 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:02:03,059 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:02:03,932 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:02:04,932 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:02:08,060 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:02:08,289 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:02:08,289 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:02:13,425 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:02:13,991 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:02:14,898 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:02:14,898 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:02:14,899 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:02:14,899 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:02:14,934 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:02:16,935 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:02:18,899 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:02:23,289 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:02:23,289 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:02:24,487 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:02:26,758 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:02:26,758 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:02:26,759 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:02:26,759 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:02:26,937 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:02:28,938 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:02:29,759 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:02:34,760 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:02:38,289 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:02:38,290 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:02:38,610 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:02:38,610 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:02:38,611 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:02:38,611 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:02:38,940 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:02:40,611 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:02:40,941 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:02:43,996 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:02:45,996 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:02:50,402 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:02:50,402 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:02:50,403 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:02:50,403 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:02:50,943 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:02:51,403 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:02:52,944 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:02:53,289 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:02:53,289 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:02:56,435 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:03:01,435 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:03:02,294 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:03:02,294 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:03:02,295 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:03:02,295 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:03:02,946 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:03:02,946 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:03:07,296 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:03:08,289 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:03:08,290 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:03:12,505 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:03:13,992 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:03:14,122 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:03:14,122 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:03:14,123 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:03:14,124 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:03:14,949 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:03:14,949 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:03:18,124 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:03:23,125 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:03:23,289 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:03:23,290 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:03:25,962 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:03:25,962 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:03:25,963 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:03:25,963 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:03:26,952 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:03:26,952 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:03:28,963 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:03:33,964 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:03:37,771 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:03:37,771 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:03:37,771 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:03:37,772 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:03:37,955 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:03:38,289 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:03:38,290 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:03:38,955 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:03:39,471 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:03:43,993 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:03:44,993 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:03:49,646 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:03:49,646 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:03:49,647 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:03:49,648 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:03:49,957 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:03:50,648 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:03:50,958 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:03:53,290 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:03:53,290 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:03:56,483 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:04:01,494 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:04:01,494 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:04:01,495 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:04:01,495 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:04:01,495 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:04:01,960 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:04:02,961 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:04:06,496 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:04:08,290 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:04:08,290 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:04:12,463 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:04:13,330 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:04:13,330 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:04:13,331 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:04:13,331 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:04:13,963 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:04:13,993 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:04:14,963 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:04:17,994 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:04:22,995 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:04:23,290 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:04:23,290 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:04:25,178 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:04:25,178 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:04:25,179 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:04:25,180 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:04:25,965 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:04:26,966 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:04:28,180 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:04:33,181 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:04:36,957 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:04:36,957 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:04:36,958 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:04:36,958 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:04:36,968 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:04:38,290 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:04:38,290 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:04:38,290 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:04:38,969 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:04:43,437 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:04:43,994 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:04:48,783 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:04:48,826 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:04:48,826 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:04:48,827 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:04:48,827 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:04:48,971 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:04:50,972 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:04:53,290 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:04:53,290 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:04:54,434 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:04:59,435 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:05:00,678 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:05:00,678 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:05:00,679 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:05:00,680 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:05:00,974 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:05:02,975 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:05:04,680 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:05:08,290 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:05:08,291 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:05:10,458 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:05:12,502 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:05:12,502 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:05:12,503 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:05:12,503 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:05:12,977 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:05:13,995 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:05:14,977 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:05:15,995 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:05:20,996 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:05:23,290 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:05:23,291 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:05:24,370 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:05:24,370 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:05:24,371 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:05:24,371 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:05:24,980 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:05:24,980 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:05:26,371 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:05:31,372 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:05:36,199 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:05:36,200 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:05:36,200 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:05:36,201 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:05:36,982 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:05:36,982 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:05:37,201 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:05:38,290 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:05:38,291 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:05:42,460 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:05:43,995 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:05:47,996 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:05:48,082 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:05:48,082 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:05:48,083 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:05:48,083 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:05:48,985 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:05:48,985 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:05:53,084 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:05:53,290 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:05:53,291 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:05:58,484 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:05:59,930 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:05:59,931 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:05:59,931 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:05:59,931 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:05:59,988 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:06:00,988 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:06:03,932 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:06:08,291 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:06:08,291 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:06:09,427 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:06:11,782 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:06:11,783 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:06:11,783 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:06:11,784 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:06:11,990 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:06:12,991 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:06:13,996 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:06:14,996 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:06:19,997 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:06:23,291 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:06:23,291 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:06:23,622 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:06:23,622 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:06:23,623 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:06:23,623 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:06:23,993 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:06:24,994 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:06:25,623 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:06:30,624 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:06:35,438 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:06:35,438 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:06:35,439 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:06:35,439 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:06:35,996 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:06:36,439 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:06:36,997 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:06:38,291 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:06:38,291 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:06:42,436 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:06:43,996 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:06:47,326 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:06:47,327 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:06:47,327 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:06:47,327 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:06:48,000 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:06:48,327 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:06:49,000 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:06:53,291 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:06:53,291 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:06:53,455 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:06:58,455 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:06:59,194 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:06:59,194 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:06:59,195 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:06:59,195 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:07:00,003 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:07:01,003 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:07:04,196 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:07:08,291 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:07:08,291 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:07:09,449 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:07:11,042 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:07:11,043 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:07:11,043 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:07:11,043 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:07:12,006 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:07:13,006 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:07:13,997 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:07:14,997 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:07:19,998 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:07:22,838 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:07:22,839 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:07:22,839 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:07:22,839 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:07:23,009 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:07:23,291 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:07:23,292 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:07:25,009 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:07:25,508 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:07:30,509 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:07:34,714 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:07:34,718 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:07:34,718 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:07:34,718 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:07:35,012 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:07:35,719 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:07:37,012 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:07:38,291 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:07:38,292 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:07:41,487 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:07:43,997 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:07:46,517 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:07:46,558 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:07:46,558 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:07:46,559 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:07:46,559 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:07:47,015 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:07:47,015 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:07:51,560 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:07:53,291 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:07:53,292 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:07:57,501 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:07:58,398 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:07:58,399 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:07:58,399 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:07:58,399 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:07:59,018 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:07:59,018 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:08:03,400 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:08:08,292 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:08:08,292 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:08:08,492 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:08:10,226 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:08:10,227 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:08:10,227 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:08:10,227 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:08:11,020 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:08:11,021 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:08:13,998 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:08:13,998 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:08:18,999 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:08:22,035 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:08:22,036 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:08:22,036 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:08:22,036 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:08:23,023 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:08:23,023 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:08:23,292 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:08:23,292 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:08:24,467 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:08:29,467 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:08:33,926 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:08:33,926 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:08:33,927 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:08:33,927 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:08:34,026 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:08:34,927 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:08:35,026 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:08:39,928 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:08:43,998 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:08:44,999 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:08:48,771 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:08:48,771 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:08:50,989 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:08:55,990 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:08:57,554 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:08:57,554 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:08:57,555 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:08:57,555 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:08:58,031 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:08:59,031 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:09:01,556 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:09:03,771 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:09:03,771 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:09:06,978 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:09:09,311 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:09:09,312 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:09:09,312 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:09:09,312 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:09:10,034 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:09:12,034 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:09:12,313 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:09:13,999 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:09:18,000 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:09:18,771 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:09:18,771 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:09:21,178 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:09:21,179 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:09:21,179 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:09:21,179 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:09:22,036 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:09:23,180 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:09:24,037 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:09:28,181 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:09:33,008 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:09:33,008 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:09:33,009 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:09:33,009 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:09:33,039 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:09:33,771 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:09:33,771 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:09:33,986 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:09:36,040 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:09:38,986 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:09:43,987 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:09:43,999 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:09:44,873 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:09:44,874 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:09:44,874 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:09:44,874 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:09:45,042 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:09:48,043 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:09:48,771 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:09:48,771 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:09:49,904 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:09:54,904 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:09:56,721 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:09:56,722 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:09:56,722 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:09:56,722 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:09:57,045 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:09:58,045 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:10:00,723 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:10:03,771 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:10:03,771 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:10:05,941 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:10:08,576 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:10:08,576 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:10:08,576 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:10:08,577 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:10:09,048 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:10:10,048 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:10:11,577 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:10:14,000 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:10:17,000 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:10:18,771 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:10:18,772 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:10:20,406 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:10:20,407 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:10:20,407 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:10:20,407 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:10:21,051 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:10:22,051 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:10:22,408 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:10:27,408 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:10:32,243 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:10:32,243 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:10:32,244 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:10:32,244 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:10:33,054 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:10:33,244 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:10:33,771 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:10:33,772 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:10:34,054 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:10:38,981 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:10:43,982 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:10:44,000 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:10:44,066 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:10:44,066 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:10:44,066 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:10:44,067 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:10:45,057 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:10:46,057 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:10:48,771 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:10:48,772 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:10:48,990 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:10:53,991 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:10:55,925 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:10:55,925 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:10:55,925 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:10:55,926 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:10:56,060 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:10:58,061 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:10:59,926 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:11:03,771 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:11:03,772 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:11:04,978 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:11:07,745 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:11:07,745 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:11:07,745 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:11:07,745 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:11:08,064 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:11:10,064 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:11:10,746 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:11:14,001 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:11:16,001 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:11:18,772 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:11:18,772 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:11:19,577 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:11:19,577 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:11:19,577 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:11:19,577 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:11:20,067 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:11:21,578 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:11:22,068 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:11:26,579 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:11:31,435 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:11:31,436 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:11:31,436 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:11:31,436 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:11:32,070 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:11:32,436 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:11:33,772 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:11:33,772 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:11:34,071 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:11:37,941 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:11:42,941 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:11:43,287 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:11:43,288 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:11:43,288 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:11:43,288 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:11:44,001 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:11:44,073 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:11:46,074 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:11:48,002 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:11:48,772 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:11:48,772 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:11:53,980 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:11:55,122 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:11:55,123 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:11:55,123 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:11:55,123 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:11:56,076 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:11:58,077 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:11:59,124 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:12:03,772 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:12:03,772 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:12:04,929 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:12:06,971 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:12:06,971 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:12:06,972 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:12:06,972 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:12:07,079 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:12:09,972 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:12:10,080 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:12:14,001 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:12:15,002 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:12:18,772 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:12:18,773 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:12:18,814 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:12:18,978 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:12:18,978 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:12:18,979 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:12:19,083 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:12:20,979 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:12:22,084 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:12:25,980 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:12:30,648 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:12:30,649 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:12:30,649 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:12:30,649 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:12:31,086 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:12:31,650 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:12:32,087 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:12:33,772 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:12:33,773 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:12:36,997 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:12:41,998 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:12:42,488 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:12:42,505 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:12:42,505 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:12:42,505 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:12:43,090 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:12:44,002 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:12:44,090 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:12:47,003 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:12:48,772 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:12:48,773 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:12:52,006 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:12:54,326 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:12:54,326 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:12:54,326 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:12:54,326 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:12:55,093 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:12:56,093 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:12:57,327 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:13:02,328 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:13:03,772 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:13:03,773 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:13:06,148 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:13:06,148 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:13:06,149 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:13:06,149 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:13:07,096 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:13:08,097 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:13:08,149 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:13:13,150 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:13:14,003 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:13:17,982 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:13:17,983 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:13:17,983 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:13:17,983 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:13:18,099 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:13:18,772 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:13:18,773 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:13:18,956 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:13:20,100 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:13:23,956 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:13:28,957 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:13:29,800 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:13:29,801 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:13:29,801 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:13:29,801 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:13:30,102 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:13:32,103 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:13:33,773 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:13:33,773 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:13:34,004 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:13:39,004 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:13:41,629 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:13:41,630 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:13:41,630 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:13:41,630 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:13:42,106 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:13:44,003 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:13:44,106 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:13:45,004 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:13:48,773 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:13:48,773 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:13:50,996 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:13:53,491 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:13:53,491 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:13:53,491 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:13:53,492 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:13:54,108 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:13:56,109 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:13:56,492 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:14:01,493 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:14:03,773 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:14:03,773 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:14:05,338 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:14:05,339 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:14:05,339 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:14:05,339 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:14:06,111 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:14:07,340 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:14:08,112 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:14:12,341 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:14:14,004 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:14:17,177 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:14:17,178 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:14:17,178 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:14:17,178 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:14:18,114 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:14:18,179 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:14:18,773 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:14:18,773 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:14:20,115 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:14:23,992 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:14:28,992 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:14:29,029 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:14:29,030 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:14:29,030 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:14:29,030 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:14:29,117 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:14:30,117 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:14:33,773 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:14:33,773 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:14:34,003 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:14:39,004 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:14:40,890 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:14:40,891 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:14:40,891 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:14:40,891 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:14:41,120 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:14:42,120 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:14:44,004 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:14:44,005 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:14:48,773 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:14:48,773 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:14:49,936 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:14:52,731 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:14:52,732 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:14:52,732 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:14:52,732 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:14:53,123 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:14:54,124 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:14:55,733 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:15:00,733 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:15:03,773 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:15:03,774 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:15:04,559 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:15:04,560 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:15:04,560 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:15:04,560 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:15:05,127 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:15:06,127 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:15:06,561 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:15:11,562 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:15:14,005 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:15:16,391 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:15:16,391 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:15:16,391 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:15:16,392 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:15:17,130 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:15:17,392 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:15:18,130 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:15:18,773 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:15:18,774 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:15:23,011 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:15:28,012 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:15:28,300 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:15:28,301 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:15:28,301 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:15:28,301 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:15:29,133 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:15:30,134 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:15:33,302 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:15:33,773 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:15:33,774 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:15:38,993 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:15:40,136 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:15:40,136 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:15:40,136 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:15:40,137 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:15:40,137 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:15:42,137 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:15:44,005 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:15:44,006 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:15:48,773 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:15:48,774 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:15:49,927 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:15:51,980 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:15:51,980 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:15:51,981 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:15:51,981 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:15:52,140 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:15:54,140 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:15:54,982 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:15:59,982 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:16:03,774 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:16:03,774 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:16:03,808 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:16:04,000 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:16:04,000 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:16:04,000 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:16:04,143 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:16:05,001 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:16:06,144 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:16:10,001 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:16:14,006 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:16:15,006 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:16:15,632 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:16:15,633 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:16:15,633 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:16:15,633 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:16:16,147 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:16:18,147 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:16:18,774 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:16:18,774 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:16:20,990 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:16:25,991 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:16:27,479 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:16:27,480 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:16:27,480 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:16:27,480 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:16:28,150 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:16:30,151 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:16:31,481 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:16:33,774 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:16:33,774 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:16:36,997 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:16:39,337 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:16:39,337 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:16:39,338 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:16:39,338 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:16:40,154 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:16:42,154 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:16:42,339 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:16:44,006 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:16:48,007 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:16:48,774 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:16:48,774 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:16:51,181 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:16:51,182 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:16:51,182 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:16:51,182 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:16:52,157 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:16:52,157 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:16:53,183 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:16:58,183 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:17:03,041 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:17:03,041 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:17:03,041 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:17:03,042 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:17:03,160 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:17:03,774 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:17:03,774 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:17:03,938 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:17:04,161 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:17:08,938 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:17:13,939 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:17:14,007 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:17:14,873 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:17:14,874 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:17:14,874 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:17:14,874 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:17:15,164 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:17:16,164 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:17:18,774 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:17:18,775 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:17:19,907 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:17:24,907 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:17:26,711 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:17:26,712 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:17:26,712 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:17:26,713 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:17:27,167 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:17:28,167 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:17:30,713 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:17:33,774 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:17:33,775 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:17:35,960 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:17:38,558 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:17:38,584 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:17:38,584 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:17:38,585 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:17:39,170 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:17:40,170 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:17:41,585 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:17:44,007 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:17:47,008 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:17:48,774 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:17:48,775 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:17:50,387 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:17:50,388 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:17:50,388 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:17:50,388 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:17:51,173 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:17:52,173 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:17:52,389 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:17:57,390 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:18:02,221 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:18:02,222 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:18:02,222 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:18:02,222 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:18:03,176 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:18:03,223 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:18:03,775 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:18:03,775 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:18:04,176 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:18:08,977 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:18:13,978 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:18:14,008 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:18:14,061 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:18:14,061 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:18:14,061 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:18:14,061 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:18:14,179 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:18:16,180 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:18:18,775 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:18:18,775 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:18:19,927 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:18:24,928 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:18:25,900 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:18:25,900 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:18:25,901 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:18:25,901 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:18:26,183 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:18:28,183 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:18:30,902 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:18:33,775 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:18:33,775 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:18:35,955 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:18:37,750 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:18:37,750 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:18:37,751 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:18:37,751 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:18:38,186 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:18:40,187 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:18:41,752 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:18:44,008 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:18:47,009 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:18:48,775 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:18:48,775 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:18:49,576 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:18:49,576 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:18:49,577 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:18:49,577 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:18:50,190 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:18:52,191 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:18:52,578 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:18:57,578 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:19:01,426 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:19:01,427 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:19:01,427 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:19:01,427 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:19:02,193 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:19:03,428 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:19:03,775 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:19:03,775 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:19:04,194 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:19:08,911 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:19:13,261 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:19:13,262 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:19:13,262 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:19:13,262 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:19:14,009 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:19:14,009 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:19:14,197 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:19:14,197 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:19:18,775 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:19:18,775 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:19:19,993 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:19:24,994 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:19:30,202 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:19:30,387 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:19:33,775 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:19:33,776 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:19:35,983 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:19:40,077 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:19:40,077 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:19:40,078 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:19:40,204 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:19:40,324 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:19:41,325 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:19:42,205 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:19:44,010 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:19:47,010 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:19:48,775 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:19:48,776 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:19:51,851 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:19:51,851 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:19:51,851 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:19:51,852 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:19:52,208 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:19:52,852 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:19:54,208 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:19:57,853 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:20:02,854 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:20:03,663 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:20:03,664 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:20:03,664 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:20:03,664 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:20:03,775 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:20:03,776 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:20:04,211 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:20:06,212 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:20:07,981 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:20:12,982 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:20:14,010 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:20:15,495 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:20:15,495 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:20:15,496 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:20:15,496 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:20:16,214 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:20:18,215 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:20:18,497 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:20:18,775 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:20:18,776 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:20:23,985 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:20:27,338 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:20:27,338 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:20:27,339 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:20:27,339 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:20:28,218 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:20:28,218 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:20:29,339 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:20:33,776 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:20:33,776 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:20:34,965 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:20:39,197 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:20:39,198 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:20:39,198 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:20:39,198 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:20:39,221 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:20:40,199 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:20:40,221 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:20:44,011 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:20:46,011 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:20:48,776 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:20:48,776 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:20:51,040 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:20:51,041 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:20:51,041 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:20:51,041 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:20:51,041 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:20:51,224 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:20:52,224 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:20:56,042 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:21:01,043 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:21:02,873 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:21:02,874 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:21:02,874 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:21:02,874 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:21:03,227 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:21:03,776 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:21:03,776 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:21:04,227 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:21:07,001 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:21:12,002 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:21:14,011 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:21:14,716 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:21:14,716 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:21:14,717 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:21:14,717 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:21:15,230 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:21:16,230 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:21:17,718 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:21:18,776 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:21:18,776 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:21:22,935 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:21:26,566 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:21:26,566 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:21:26,566 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:21:26,567 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:21:27,233 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:21:28,233 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:21:28,567 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:21:33,568 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:21:33,776 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:21:33,776 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:21:38,399 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:21:38,400 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:21:38,400 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:21:38,400 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:21:39,236 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:21:39,401 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:21:40,237 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:21:44,012 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:21:45,012 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:21:48,776 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:21:48,776 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:21:50,242 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:21:50,242 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:21:50,243 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:21:50,243 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:21:50,243 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:21:51,239 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:21:52,240 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:21:55,244 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:22:00,245 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:22:02,064 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:22:02,065 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:22:02,065 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:22:02,065 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:22:02,242 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:22:03,776 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:22:03,776 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:22:04,243 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:22:05,917 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:22:10,918 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:22:13,898 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:22:13,899 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:22:13,899 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:22:13,899 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:22:14,012 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:22:14,245 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:22:16,013 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:22:16,246 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:22:18,776 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:22:18,777 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:22:21,918 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:22:25,750 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:22:25,754 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:22:25,755 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:22:25,755 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:22:26,248 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:22:27,756 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:22:28,249 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:22:32,756 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:22:33,776 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:22:33,777 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:22:37,597 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:22:37,597 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:22:37,598 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:22:37,598 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:22:38,251 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:22:38,598 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:22:40,252 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:22:43,599 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:22:44,012 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:22:48,776 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:22:48,777 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:22:48,961 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:22:49,422 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:22:49,422 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:22:49,422 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:22:49,423 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:22:50,254 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:22:50,254 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:22:54,424 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:22:59,424 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:23:01,275 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:23:01,276 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:23:01,276 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:23:01,276 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:23:02,257 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:23:02,257 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:23:03,777 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:23:03,777 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:23:04,898 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:23:09,899 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:23:13,088 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:23:13,088 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:23:13,089 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:23:13,089 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:23:13,260 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:23:14,013 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:23:14,260 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:23:15,014 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:23:18,777 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:23:18,777 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:23:21,007 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:23:24,906 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:23:24,907 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:23:24,907 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:23:24,907 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:23:25,263 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:23:26,263 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:23:26,908 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:23:31,909 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:23:33,777 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:23:33,777 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:23:36,729 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:23:36,730 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:23:36,730 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:23:36,730 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:23:37,266 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:23:37,731 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:23:38,267 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:23:42,731 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:23:44,013 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:23:48,014 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:23:48,564 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:23:48,564 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:23:48,565 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:23:48,565 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:23:48,777 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:23:48,777 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:23:49,269 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:23:50,270 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:23:53,914 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:23:58,915 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:24:00,394 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:24:00,395 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:24:00,395 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:24:00,395 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:24:01,272 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:24:02,273 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:24:03,777 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:24:03,777 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:24:03,978 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:24:08,979 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:24:12,219 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:24:12,220 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:24:12,220 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:24:12,220 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:24:12,275 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:24:14,014 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:24:14,014 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:24:14,276 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:24:18,777 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:24:18,777 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:24:19,992 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:24:24,062 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:24:24,062 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:24:24,063 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:24:24,063 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:24:24,279 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:24:25,063 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:24:26,279 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:24:30,064 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:24:33,777 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:24:33,777 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:24:35,899 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:24:35,899 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:24:35,899 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:24:35,900 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:24:35,900 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:24:36,281 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:24:38,282 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:24:40,901 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:24:44,015 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:24:46,015 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:24:47,737 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:24:47,737 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:24:47,737 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:24:47,738 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:24:48,285 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:24:48,285 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:24:48,777 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:24:48,778 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:24:51,992 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:24:56,993 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:24:59,563 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:24:59,564 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:24:59,564 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:24:59,564 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:25:00,288 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:25:00,288 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:25:02,565 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:25:03,777 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:25:03,778 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:25:07,996 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:25:11,417 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:25:11,418 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:25:11,418 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:25:11,418 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:25:12,291 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:25:12,291 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:25:13,419 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:25:14,015 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:25:18,778 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:25:18,778 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:25:18,971 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:25:23,221 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:25:23,222 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:25:23,222 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:25:23,222 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:25:23,294 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:25:24,222 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:25:24,294 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:25:29,223 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:25:33,778 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:25:33,778 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:25:35,008 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:25:35,048 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:25:35,048 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:25:35,049 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:25:35,049 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:25:35,297 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:25:36,297 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:25:40,050 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:25:44,016 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:25:46,016 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:25:46,884 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:25:46,885 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:25:46,885 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:25:46,885 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:25:47,300 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:25:48,300 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:25:48,778 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:25:48,778 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:25:51,939 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:25:56,940 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:25:58,727 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:25:58,727 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:25:58,728 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:25:58,728 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:25:59,303 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:26:00,303 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:26:02,729 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:26:03,778 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:26:03,778 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:26:07,965 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:26:10,598 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:26:10,598 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:26:10,599 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:26:10,599 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:26:11,306 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:26:12,307 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:26:13,600 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:26:14,016 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:26:18,778 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:26:18,778 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:26:18,965 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:26:22,440 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:26:22,440 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:26:22,441 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:26:22,441 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:26:23,309 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:26:24,310 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:26:24,441 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:26:29,442 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:26:33,778 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:26:33,778 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:26:34,255 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:26:34,256 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:26:34,256 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:26:34,256 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:26:34,312 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:26:35,256 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:26:36,313 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:26:40,257 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:26:44,017 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:26:46,017 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:26:46,071 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:26:46,071 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:26:46,071 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:26:46,072 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:26:46,315 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:26:48,316 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:26:48,778 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:26:48,778 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:26:52,009 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:26:57,009 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:26:57,891 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:26:57,891 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:26:57,891 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:26:57,892 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:26:58,318 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:26:59,319 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:27:02,892 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:27:03,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:27:03,779 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:27:08,067 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:27:09,721 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:27:09,722 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:27:09,722 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:27:09,722 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:27:10,321 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:27:11,321 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:27:13,723 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:27:14,020 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:27:18,778 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:27:18,779 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:27:18,942 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:27:21,576 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:27:21,576 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:27:21,576 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:27:21,577 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:27:22,324 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:27:23,324 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:27:24,577 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:27:29,578 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:27:33,400 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:27:33,401 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:27:33,401 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:27:33,401 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:27:33,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:27:33,779 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:27:34,327 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:27:34,965 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:27:35,327 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:27:39,966 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:27:44,018 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:27:45,018 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:27:45,237 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:27:45,237 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:27:45,237 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:27:45,238 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:27:45,330 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:27:47,330 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:27:48,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:27:48,779 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:27:50,929 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:27:55,930 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:27:57,067 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:27:57,068 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:27:57,068 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:27:57,068 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:27:57,333 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:27:59,334 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:28:01,069 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:28:03,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:28:03,779 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:28:06,932 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:28:08,899 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:28:08,900 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:28:08,900 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:28:08,900 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:28:09,336 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:28:11,337 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:28:12,901 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:28:14,018 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:28:18,019 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:28:18,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:28:18,779 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:28:20,749 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:28:20,749 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:28:20,749 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:28:20,750 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:28:21,340 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:28:23,340 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:28:23,751 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:28:28,752 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:28:32,592 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:28:32,593 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:28:32,593 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:28:32,593 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:28:33,343 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:28:33,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:28:33,779 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:28:33,917 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:28:35,344 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:28:38,917 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:28:43,918 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:28:44,019 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:28:44,414 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:28:44,414 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:28:44,414 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:28:44,415 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:28:45,347 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:28:47,347 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:28:48,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:28:48,779 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:28:49,020 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:28:54,021 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:28:56,247 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:28:56,248 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:28:56,248 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:28:56,249 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:28:56,350 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:28:59,250 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:28:59,351 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:29:03,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:29:03,779 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:29:04,986 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:29:08,085 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:29:08,085 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:29:08,085 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:29:08,086 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:29:08,353 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:29:10,086 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:29:11,354 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:29:14,019 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:29:16,020 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:29:18,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:29:18,779 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:29:19,927 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:29:19,927 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:29:19,928 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:29:19,928 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:29:20,357 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:29:21,357 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:29:21,928 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:29:26,929 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:29:31,763 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:29:31,764 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:29:31,764 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:29:31,765 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:29:32,360 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:29:32,766 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:29:33,361 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:29:33,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:29:33,779 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:29:37,910 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:29:42,910 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:29:43,601 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:29:43,601 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:29:43,601 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:29:43,602 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:29:44,020 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:29:44,364 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:29:45,364 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:29:48,020 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:29:48,780 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:29:48,780 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:29:53,999 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:29:55,445 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:29:55,446 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:29:55,446 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:29:55,446 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:29:56,367 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:29:57,367 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:29:59,447 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:30:03,779 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:30:03,780 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:30:04,997 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:30:07,304 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:30:07,304 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:30:07,304 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:30:07,305 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:30:07,370 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:30:09,371 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:30:10,306 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:30:14,020 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:30:16,021 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:30:18,780 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:30:18,780 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:30:19,148 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:30:19,149 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:30:19,149 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:30:19,149 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:30:19,373 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:30:21,150 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:30:21,374 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:30:26,150 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:30:30,984 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:30:30,985 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:30:30,985 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:30:30,985 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:30:31,376 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:30:31,985 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:30:33,377 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:30:33,780 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:30:33,780 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:30:37,903 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:30:42,837 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:30:42,838 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:30:42,838 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:30:42,839 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:30:43,380 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:30:43,839 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:30:44,021 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:30:45,380 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:30:48,780 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:30:48,780 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:30:48,899 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:30:53,900 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:30:54,678 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:30:54,678 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:30:54,678 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:30:54,678 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:30:55,383 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:30:57,384 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:30:59,679 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:31:03,780 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:31:03,780 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:31:04,907 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:31:06,512 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:31:06,513 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:31:06,513 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:31:06,513 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:31:07,386 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:31:09,387 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:31:10,514 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:31:14,021 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:31:16,022 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:31:18,340 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:31:18,341 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:31:18,341 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:31:18,341 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:31:18,389 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:31:18,780 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:31:18,780 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:31:21,390 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:31:21,921 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:31:26,922 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:31:30,172 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:31:30,173 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:31:30,173 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:31:30,173 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:31:30,393 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:31:31,393 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:31:32,174 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:31:33,780 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:31:33,781 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:31:37,969 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:31:42,015 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:31:42,015 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:31:42,015 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:31:42,016 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:31:42,396 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:31:43,016 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:31:43,396 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:31:44,022 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:31:48,022 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:31:48,780 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:31:48,781 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:31:53,842 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:31:53,842 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:31:53,842 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:31:53,842 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:31:53,843 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:31:54,399 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:31:55,399 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:31:58,844 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:32:03,781 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:32:03,781 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:32:04,001 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:32:05,683 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:32:05,684 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:32:05,684 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:32:05,684 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:32:06,402 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:32:07,402 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:32:09,685 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:32:14,029 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:32:15,030 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:32:17,511 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:32:17,511 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:32:17,512 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:32:17,512 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:32:18,405 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:32:18,781 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:32:18,781 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:32:19,405 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:32:20,908 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:32:25,909 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:32:29,341 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:32:29,341 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:32:29,342 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:32:29,342 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:32:29,408 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:32:31,342 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:32:31,408 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:32:33,781 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:32:33,781 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:32:37,015 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:32:41,168 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:32:41,168 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:32:41,169 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:32:41,169 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:32:41,410 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:32:42,169 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:32:43,411 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:32:44,023 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:32:48,023 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:32:48,781 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:32:48,781 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:32:53,024 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:32:53,025 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:32:53,025 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:32:53,025 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:32:53,026 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:32:53,413 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:32:55,414 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:32:58,027 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:33:03,027 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:33:03,781 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:33:03,781 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:33:04,861 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:33:04,862 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:33:04,862 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:33:04,862 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:33:05,416 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:33:07,417 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:33:08,863 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:33:13,864 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:33:14,023 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:33:18,781 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:33:18,782 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:33:18,967 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:33:23,968 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:33:28,140 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:33:28,141 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:33:28,141 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:33:28,142 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:33:28,422 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:33:29,142 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:33:29,422 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:33:33,781 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:33:33,782 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:33:34,993 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:33:39,916 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:33:39,917 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:33:39,917 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:33:39,917 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:33:40,425 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:33:40,917 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:33:41,425 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:33:44,024 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:33:46,024 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:33:48,781 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:33:48,782 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:33:51,743 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:33:51,743 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:33:51,743 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:33:51,743 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:33:51,744 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:33:52,427 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:33:53,428 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:33:56,744 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:34:01,745 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:34:03,574 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:34:03,575 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:34:03,575 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:34:03,576 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:34:03,782 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:34:03,782 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:34:04,430 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:34:05,430 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:34:06,908 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:34:11,909 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:34:14,024 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:34:15,404 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:34:15,404 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:34:15,404 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:34:15,405 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:34:15,432 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:34:17,405 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:34:17,433 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:34:18,782 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:34:18,782 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:34:22,970 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:34:27,246 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:34:27,247 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:34:27,247 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:34:27,247 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:34:27,435 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:34:28,248 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:34:29,436 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:34:33,248 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:34:33,782 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:34:33,782 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:34:39,002 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:34:39,095 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:34:39,096 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:34:39,096 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:34:39,097 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:34:39,438 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:34:41,439 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:34:44,025 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:34:44,025 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:34:48,782 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:34:48,782 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:34:49,950 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:34:50,953 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:34:50,954 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:34:50,954 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:34:50,954 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:34:51,442 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:34:53,442 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:34:54,955 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:34:59,955 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:35:02,809 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:35:02,809 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:35:02,809 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:35:02,810 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:35:03,445 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:35:03,782 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:35:03,782 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:35:05,446 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:35:05,821 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:35:10,822 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:35:14,025 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:35:14,677 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:35:14,678 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:35:14,678 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:35:14,678 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:35:15,448 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:35:16,679 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:35:17,449 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:35:18,782 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:35:18,783 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:35:21,917 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:35:26,509 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:35:26,510 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:35:26,510 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:35:26,510 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:35:27,452 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:35:27,510 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:35:29,452 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:35:32,511 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:35:33,782 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:35:33,783 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:35:37,961 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:35:38,355 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:35:38,355 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:35:38,356 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:35:38,356 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:35:38,454 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:35:39,455 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:35:43,357 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:35:44,026 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:35:48,782 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:35:48,783 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:35:48,938 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:35:50,199 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:35:50,199 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:35:50,199 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:35:50,200 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:35:50,458 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:35:51,458 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:35:54,200 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:35:59,201 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:36:02,037 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:36:02,038 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:36:02,038 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:36:02,038 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:36:02,460 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:36:03,460 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:36:03,783 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:36:03,783 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:36:04,948 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:36:09,949 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:36:13,879 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:36:13,879 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:36:13,879 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:36:13,880 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:36:14,026 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:36:14,463 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:36:15,027 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:36:15,463 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:36:18,783 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:36:18,783 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:36:20,971 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:36:25,731 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:36:25,731 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:36:25,732 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:36:25,732 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:36:26,466 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:36:26,732 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:36:27,466 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:36:31,733 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:36:33,783 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:36:33,783 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:36:36,945 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:36:37,610 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:36:37,611 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:36:37,611 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:36:37,611 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:36:38,468 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:36:39,469 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:36:42,612 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:36:44,027 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:36:48,028 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:36:48,783 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:36:48,783 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:36:49,460 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:36:49,461 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:36:49,461 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:36:49,461 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:36:49,471 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:36:51,472 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:36:53,462 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:36:58,463 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:37:01,297 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:37:01,298 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:37:01,298 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:37:01,298 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:37:01,474 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:37:03,474 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:37:03,783 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:37:03,783 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:37:03,924 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:37:08,925 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:37:13,143 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:37:13,143 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:37:13,143 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:37:13,144 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:37:13,477 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:37:14,031 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:37:14,032 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:37:15,477 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:37:18,783 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:37:18,784 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:37:20,000 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:37:24,980 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:37:24,981 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:37:24,981 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:37:24,981 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:37:25,479 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:37:25,982 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:37:27,480 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:37:30,983 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:37:33,783 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:37:33,784 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:37:36,810 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:37:36,811 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:37:36,811 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:37:36,811 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:37:36,811 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:37:37,482 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:37:39,483 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:37:41,812 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:37:44,028 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:37:47,028 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:37:48,659 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:37:48,659 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:37:48,660 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:37:48,660 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:37:48,783 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:37:48,784 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:37:49,485 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:37:51,486 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:37:53,018 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:37:58,019 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:38:00,500 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:38:00,500 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:38:00,500 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:38:00,501 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:38:01,488 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:38:01,488 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:38:03,501 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:38:03,784 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:38:03,784 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:38:08,937 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:38:12,337 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:38:12,337 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:38:12,338 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:38:12,338 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:38:12,491 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:38:13,491 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:38:14,028 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:38:14,029 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:38:18,784 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:38:18,784 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:38:19,946 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:38:24,195 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:38:24,195 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:38:24,196 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:38:24,197 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:38:24,493 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:38:25,197 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:38:25,494 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:38:30,198 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:38:33,784 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:38:33,784 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:38:35,999 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:38:36,058 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:38:36,059 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:38:36,059 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:38:36,059 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:38:36,496 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:38:37,497 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:38:41,060 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:38:44,029 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:38:47,030 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:38:47,912 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:38:47,913 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:38:47,913 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:38:47,913 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:38:48,499 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:38:48,784 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:38:48,784 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:38:49,499 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:38:52,994 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:38:57,994 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:38:59,759 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:38:59,759 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:38:59,760 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:38:59,761 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:39:00,502 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:39:01,502 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:39:03,761 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:39:03,784 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:39:03,784 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:39:09,002 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:39:11,610 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:39:11,610 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:39:11,611 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:39:11,611 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:39:12,505 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:39:13,505 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:39:14,029 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:39:14,030 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:39:18,784 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:39:18,785 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:39:19,918 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:39:23,465 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: partial_history +2024-05-25 23:39:23,465 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:39:23,465 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:39:23,466 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:39:23,508 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:39:25,466 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:39:25,508 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:39:30,467 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:39:35,468 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:39:37,817 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: stop_status +2024-05-25 23:39:37,818 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: stop_status +2024-05-25 23:39:38,634 DEBUG SenderThread:43320 [sender.py:send():378] send: telemetry +2024-05-25 23:39:38,634 DEBUG SenderThread:43320 [sender.py:send():378] send: exit +2024-05-25 23:39:38,634 INFO SenderThread:43320 [sender.py:send_exit():585] handling exit code: 0 +2024-05-25 23:39:38,635 INFO SenderThread:43320 [sender.py:send_exit():587] handling runtime: 6774 +2024-05-25 23:39:38,636 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:39:38,636 INFO SenderThread:43320 [sender.py:send_exit():593] send defer +2024-05-25 23:39:38,636 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: defer +2024-05-25 23:39:38,636 INFO HandlerThread:43320 [handler.py:handle_request_defer():184] handle defer: 0 +2024-05-25 23:39:38,636 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: defer +2024-05-25 23:39:38,636 INFO SenderThread:43320 [sender.py:send_request_defer():609] handle sender defer: 0 +2024-05-25 23:39:38,636 INFO SenderThread:43320 [sender.py:transition_state():613] send defer: 1 +2024-05-25 23:39:38,636 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: defer +2024-05-25 23:39:38,636 INFO HandlerThread:43320 [handler.py:handle_request_defer():184] handle defer: 1 +2024-05-25 23:39:38,636 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: defer +2024-05-25 23:39:38,636 INFO SenderThread:43320 [sender.py:send_request_defer():609] handle sender defer: 1 +2024-05-25 23:39:38,636 INFO SenderThread:43320 [sender.py:transition_state():613] send defer: 2 +2024-05-25 23:39:38,636 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: defer +2024-05-25 23:39:38,636 INFO HandlerThread:43320 [handler.py:handle_request_defer():184] handle defer: 2 +2024-05-25 23:39:38,636 INFO HandlerThread:43320 [system_monitor.py:finish():203] Stopping system monitor +2024-05-25 23:39:38,636 DEBUG SystemMonitor:43320 [system_monitor.py:_start():179] Finished system metrics aggregation loop +2024-05-25 23:39:38,637 DEBUG SystemMonitor:43320 [system_monitor.py:_start():183] Publishing last batch of metrics +2024-05-25 23:39:38,637 INFO HandlerThread:43320 [interfaces.py:finish():200] Joined cpu monitor +2024-05-25 23:39:38,637 INFO HandlerThread:43320 [interfaces.py:finish():200] Joined disk monitor +2024-05-25 23:39:38,660 INFO HandlerThread:43320 [interfaces.py:finish():200] Joined gpu monitor +2024-05-25 23:39:38,660 INFO HandlerThread:43320 [interfaces.py:finish():200] Joined memory monitor +2024-05-25 23:39:38,660 INFO HandlerThread:43320 [interfaces.py:finish():200] Joined network monitor +2024-05-25 23:39:38,660 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: defer +2024-05-25 23:39:38,660 INFO SenderThread:43320 [sender.py:send_request_defer():609] handle sender defer: 2 +2024-05-25 23:39:38,660 INFO SenderThread:43320 [sender.py:transition_state():613] send defer: 3 +2024-05-25 23:39:38,660 DEBUG SenderThread:43320 [sender.py:send():378] send: stats +2024-05-25 23:39:38,660 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: defer +2024-05-25 23:39:38,660 INFO HandlerThread:43320 [handler.py:handle_request_defer():184] handle defer: 3 +2024-05-25 23:39:38,661 DEBUG SenderThread:43320 [sender.py:send():378] send: history +2024-05-25 23:39:38,661 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: summary_record +2024-05-25 23:39:38,661 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:39:38,661 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: defer +2024-05-25 23:39:38,661 INFO SenderThread:43320 [sender.py:send_request_defer():609] handle sender defer: 3 +2024-05-25 23:39:38,661 INFO SenderThread:43320 [sender.py:transition_state():613] send defer: 4 +2024-05-25 23:39:38,661 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: defer +2024-05-25 23:39:38,661 INFO HandlerThread:43320 [handler.py:handle_request_defer():184] handle defer: 4 +2024-05-25 23:39:38,661 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: defer +2024-05-25 23:39:38,661 INFO SenderThread:43320 [sender.py:send_request_defer():609] handle sender defer: 4 +2024-05-25 23:39:38,661 INFO SenderThread:43320 [sender.py:transition_state():613] send defer: 5 +2024-05-25 23:39:38,661 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: defer +2024-05-25 23:39:38,661 INFO HandlerThread:43320 [handler.py:handle_request_defer():184] handle defer: 5 +2024-05-25 23:39:38,661 DEBUG SenderThread:43320 [sender.py:send():378] send: summary +2024-05-25 23:39:38,662 INFO SenderThread:43320 [sender.py:_save_file():1389] saving file wandb-summary.json with policy end +2024-05-25 23:39:38,662 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: defer +2024-05-25 23:39:38,662 INFO SenderThread:43320 [sender.py:send_request_defer():609] handle sender defer: 5 +2024-05-25 23:39:38,662 INFO SenderThread:43320 [sender.py:transition_state():613] send defer: 6 +2024-05-25 23:39:38,662 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: defer +2024-05-25 23:39:38,662 INFO HandlerThread:43320 [handler.py:handle_request_defer():184] handle defer: 6 +2024-05-25 23:39:38,662 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: defer +2024-05-25 23:39:38,662 INFO SenderThread:43320 [sender.py:send_request_defer():609] handle sender defer: 6 +2024-05-25 23:39:38,664 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: status_report +2024-05-25 23:39:38,813 INFO SenderThread:43320 [sender.py:transition_state():613] send defer: 7 +2024-05-25 23:39:38,813 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: defer +2024-05-25 23:39:38,813 INFO HandlerThread:43320 [handler.py:handle_request_defer():184] handle defer: 7 +2024-05-25 23:39:38,813 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: defer +2024-05-25 23:39:38,813 INFO SenderThread:43320 [sender.py:send_request_defer():609] handle sender defer: 7 +2024-05-25 23:39:39,511 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:39:39,512 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/config.yaml +2024-05-25 23:39:39,512 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:39:39,606 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: poll_exit +2024-05-25 23:39:41,261 INFO SenderThread:43320 [sender.py:transition_state():613] send defer: 8 +2024-05-25 23:39:41,262 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: poll_exit +2024-05-25 23:39:41,262 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: defer +2024-05-25 23:39:41,262 INFO HandlerThread:43320 [handler.py:handle_request_defer():184] handle defer: 8 +2024-05-25 23:39:41,262 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: defer +2024-05-25 23:39:41,262 INFO SenderThread:43320 [sender.py:send_request_defer():609] handle sender defer: 8 +2024-05-25 23:39:41,262 INFO SenderThread:43320 [job_builder.py:build():432] Attempting to build job artifact +2024-05-25 23:39:41,263 INFO SenderThread:43320 [job_builder.py:_get_source_type():565] is repo sourced job +2024-05-25 23:39:41,263 WARNING SenderThread:43320 [job_builder.py:_log_if_verbose():267] No program path found, not creating job artifact. See https://docs.wandb.ai/guides/launch/create-job +2024-05-25 23:39:41,263 INFO SenderThread:43320 [sender.py:transition_state():613] send defer: 9 +2024-05-25 23:39:41,263 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: defer +2024-05-25 23:39:41,263 INFO HandlerThread:43320 [handler.py:handle_request_defer():184] handle defer: 9 +2024-05-25 23:39:41,263 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: defer +2024-05-25 23:39:41,263 INFO SenderThread:43320 [sender.py:send_request_defer():609] handle sender defer: 9 +2024-05-25 23:39:41,263 INFO SenderThread:43320 [dir_watcher.py:finish():358] shutting down directory watcher +2024-05-25 23:39:41,512 INFO Thread-12 :43320 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:39:41,513 INFO SenderThread:43320 [dir_watcher.py:finish():388] scan: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files +2024-05-25 23:39:41,513 INFO SenderThread:43320 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/conda-environment.yaml conda-environment.yaml +2024-05-25 23:39:41,513 INFO SenderThread:43320 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log output.log +2024-05-25 23:39:41,513 INFO SenderThread:43320 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-metadata.json wandb-metadata.json +2024-05-25 23:39:41,513 INFO SenderThread:43320 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/config.yaml config.yaml +2024-05-25 23:39:41,513 INFO SenderThread:43320 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/requirements.txt requirements.txt +2024-05-25 23:39:41,513 INFO SenderThread:43320 [dir_watcher.py:finish():402] scan save: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json wandb-summary.json +2024-05-25 23:39:41,513 INFO SenderThread:43320 [sender.py:transition_state():613] send defer: 10 +2024-05-25 23:39:41,515 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: defer +2024-05-25 23:39:41,515 INFO HandlerThread:43320 [handler.py:handle_request_defer():184] handle defer: 10 +2024-05-25 23:39:41,516 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: defer +2024-05-25 23:39:41,516 INFO SenderThread:43320 [sender.py:send_request_defer():609] handle sender defer: 10 +2024-05-25 23:39:41,517 INFO SenderThread:43320 [file_pusher.py:finish():169] shutting down file pusher +2024-05-25 23:39:41,607 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: poll_exit +2024-05-25 23:39:41,607 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: poll_exit +2024-05-25 23:39:41,861 INFO wandb-upload_1:43320 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/conda-environment.yaml +2024-05-25 23:39:41,879 INFO wandb-upload_4:43320 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/wandb-summary.json +2024-05-25 23:39:41,886 INFO wandb-upload_2:43320 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/config.yaml +2024-05-25 23:39:42,088 INFO wandb-upload_3:43320 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/requirements.txt +2024-05-25 23:39:42,129 INFO wandb-upload_0:43320 [upload_job.py:push():130] Uploaded file /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/files/output.log +2024-05-25 23:39:42,330 INFO Thread-11 (_thread_body):43320 [sender.py:transition_state():613] send defer: 11 +2024-05-25 23:39:42,330 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: defer +2024-05-25 23:39:42,330 INFO HandlerThread:43320 [handler.py:handle_request_defer():184] handle defer: 11 +2024-05-25 23:39:42,331 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: defer +2024-05-25 23:39:42,331 INFO SenderThread:43320 [sender.py:send_request_defer():609] handle sender defer: 11 +2024-05-25 23:39:42,331 INFO SenderThread:43320 [file_pusher.py:join():175] waiting for file pusher +2024-05-25 23:39:42,331 INFO SenderThread:43320 [sender.py:transition_state():613] send defer: 12 +2024-05-25 23:39:42,331 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: defer +2024-05-25 23:39:42,331 INFO HandlerThread:43320 [handler.py:handle_request_defer():184] handle defer: 12 +2024-05-25 23:39:42,331 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: defer +2024-05-25 23:39:42,331 INFO SenderThread:43320 [sender.py:send_request_defer():609] handle sender defer: 12 +2024-05-25 23:39:42,331 INFO SenderThread:43320 [file_stream.py:finish():601] file stream finish called +2024-05-25 23:39:42,607 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: poll_exit +2024-05-25 23:39:42,730 INFO SenderThread:43320 [file_stream.py:finish():605] file stream finish is done +2024-05-25 23:39:42,730 INFO SenderThread:43320 [sender.py:transition_state():613] send defer: 13 +2024-05-25 23:39:42,730 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: poll_exit +2024-05-25 23:39:42,731 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: defer +2024-05-25 23:39:42,731 INFO HandlerThread:43320 [handler.py:handle_request_defer():184] handle defer: 13 +2024-05-25 23:39:42,731 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: defer +2024-05-25 23:39:42,731 INFO SenderThread:43320 [sender.py:send_request_defer():609] handle sender defer: 13 +2024-05-25 23:39:42,731 INFO SenderThread:43320 [sender.py:transition_state():613] send defer: 14 +2024-05-25 23:39:42,731 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: defer +2024-05-25 23:39:42,731 INFO HandlerThread:43320 [handler.py:handle_request_defer():184] handle defer: 14 +2024-05-25 23:39:42,731 DEBUG SenderThread:43320 [sender.py:send():378] send: final +2024-05-25 23:39:42,731 DEBUG SenderThread:43320 [sender.py:send():378] send: footer +2024-05-25 23:39:42,731 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: defer +2024-05-25 23:39:42,731 INFO SenderThread:43320 [sender.py:send_request_defer():609] handle sender defer: 14 +2024-05-25 23:39:42,732 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: poll_exit +2024-05-25 23:39:42,732 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: poll_exit +2024-05-25 23:39:42,732 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: internal_messages +2024-05-25 23:39:42,733 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: server_info +2024-05-25 23:39:42,733 DEBUG SenderThread:43320 [sender.py:send_request():405] send_request: server_info +2024-05-25 23:39:42,774 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: get_summary +2024-05-25 23:39:42,774 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: sampled_history +2024-05-25 23:39:42,862 DEBUG HandlerThread:43320 [handler.py:handle_request():158] handle_request: shutdown +2024-05-25 23:39:42,862 INFO HandlerThread:43320 [handler.py:finish():882] shutting down handler +2024-05-25 23:39:43,733 INFO WriterThread:43320 [datastore.py:close():296] close: /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/run-cngfo6vp.wandb +2024-05-25 23:39:43,861 INFO SenderThread:43320 [sender.py:finish():1545] shutting down sender +2024-05-25 23:39:43,861 INFO SenderThread:43320 [file_pusher.py:finish():169] shutting down file pusher +2024-05-25 23:39:43,861 INFO SenderThread:43320 [file_pusher.py:join():175] waiting for file pusher diff --git a/runseed5/wandb/run-20240525_214643-cngfo6vp/logs/debug.log b/runseed5/wandb/run-20240525_214643-cngfo6vp/logs/debug.log new file mode 100644 index 0000000000000000000000000000000000000000..3bd98328ecd142325a3be8e820946229b1b99447 --- /dev/null +++ b/runseed5/wandb/run-20240525_214643-cngfo6vp/logs/debug.log @@ -0,0 +1,36 @@ +2024-05-25 21:46:43,430 INFO MainThread:43269 [wandb_setup.py:_flush():76] Current SDK version is 0.17.0 +2024-05-25 21:46:43,430 INFO MainThread:43269 [wandb_setup.py:_flush():76] Configure stats pid to 43269 +2024-05-25 21:46:43,430 INFO MainThread:43269 [wandb_setup.py:_flush():76] Loading settings from /root/.config/wandb/settings +2024-05-25 21:46:43,430 INFO MainThread:43269 [wandb_setup.py:_flush():76] Loading settings from /root/mistral-finetune/wandb/settings +2024-05-25 21:46:43,430 INFO MainThread:43269 [wandb_setup.py:_flush():76] Loading settings from environment variables: {} +2024-05-25 21:46:43,430 WARNING MainThread:43269 [wandb_setup.py:_flush():76] Could not find program at -m train +2024-05-25 21:46:43,430 INFO MainThread:43269 [wandb_setup.py:_flush():76] Inferring run settings from compute environment: {'program_relpath': None, 'program': '-m train'} +2024-05-25 21:46:43,430 INFO MainThread:43269 [wandb_setup.py:_flush():76] Applying login settings: {'api_key': '***REDACTED***'} +2024-05-25 21:46:43,430 INFO MainThread:43269 [wandb_setup.py:_flush():76] Applying login settings: {'api_key': '***REDACTED***'} +2024-05-25 21:46:43,430 INFO MainThread:43269 [wandb_setup.py:_flush():76] Applying login settings: {} +2024-05-25 21:46:43,430 INFO MainThread:43269 [wandb_init.py:_log_setup():520] Logging user logs to /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/logs/debug.log +2024-05-25 21:46:43,430 INFO MainThread:43269 [wandb_init.py:_log_setup():521] Logging internal logs to /root/mistral-finetune/runseed5/wandb/run-20240525_214643-cngfo6vp/logs/debug-internal.log +2024-05-25 21:46:43,430 INFO MainThread:43269 [wandb_init.py:init():560] calling init triggers +2024-05-25 21:46:43,430 INFO MainThread:43269 [wandb_init.py:init():567] wandb.init called with sweep_config: {} +config: {'data': {'data': '', 'shuffle': False, 'instruct_data': '/root/data/mol_instructions_train.jsonl', 'eval_instruct_data': '', 'instruct': {'shuffle': True, 'dynamic_chunk_fn_call': True}}, 'model_id_or_path': '/root/mistral_models/7B-v0.3', 'run_dir': '/root/mistral-finetune/runseed5', 'optim': {'lr': 6e-05, 'weight_decay': 0.1, 'pct_start': 0.05}, 'seed': 5, 'num_microbatches': 1, 'seq_len': 32768, 'batch_size': 2, 'max_norm': 1.0, 'max_steps': 500, 'log_freq': 1, 'ckpt_freq': 100, 'ckpt_only_lora': False, 'no_ckpt': False, 'num_ckpt_keep': 3, 'eval_freq': 100, 'no_eval': True, 'checkpoint': True, 'world_size': 1, 'wandb': {'project': 'CHEMISTral7b-ft', 'offline': False, 'key': 'aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df', 'run_name': 'run1'}, 'mlflow': {'tracking_uri': None, 'experiment_name': None}, 'lora': {'enable': True, 'rank': 64, 'dropout': 0.0, 'scaling': 2.0}} +2024-05-25 21:46:43,430 INFO MainThread:43269 [wandb_init.py:init():610] starting backend +2024-05-25 21:46:43,430 INFO MainThread:43269 [wandb_init.py:init():614] setting up manager +2024-05-25 21:46:43,431 INFO MainThread:43269 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn +2024-05-25 21:46:43,431 INFO MainThread:43269 [wandb_init.py:init():622] backend started and connected +2024-05-25 21:46:43,433 INFO MainThread:43269 [wandb_init.py:init():711] updated telemetry +2024-05-25 21:46:43,435 INFO MainThread:43269 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout +2024-05-25 21:46:43,827 INFO MainThread:43269 [wandb_run.py:_on_init():2396] communicating current version +2024-05-25 21:46:43,860 INFO MainThread:43269 [wandb_run.py:_on_init():2405] got version response +2024-05-25 21:46:43,860 INFO MainThread:43269 [wandb_init.py:init():795] starting run threads in backend +2024-05-25 21:46:44,924 INFO MainThread:43269 [wandb_run.py:_console_start():2374] atexit reg +2024-05-25 21:46:44,924 INFO MainThread:43269 [wandb_run.py:_redirect():2229] redirect: wrap_raw +2024-05-25 21:46:44,924 INFO MainThread:43269 [wandb_run.py:_redirect():2294] Wrapping output streams. +2024-05-25 21:46:44,924 INFO MainThread:43269 [wandb_run.py:_redirect():2319] Redirects installed. +2024-05-25 21:46:44,924 INFO MainThread:43269 [wandb_init.py:init():838] run started, returning control to user process +2024-05-25 23:39:38,605 INFO MainThread:43269 [wandb_run.py:_finish():2103] finishing run artsy/CHEMISTral7b-ft/cngfo6vp +2024-05-25 23:39:38,605 INFO MainThread:43269 [wandb_run.py:_atexit_cleanup():2343] got exitcode: 0 +2024-05-25 23:39:38,606 INFO MainThread:43269 [wandb_run.py:_restore():2326] restore +2024-05-25 23:39:38,606 INFO MainThread:43269 [wandb_run.py:_restore():2332] restore done +2024-05-25 23:39:43,863 INFO MainThread:43269 [wandb_run.py:_footer_history_summary_info():3994] rendering history +2024-05-25 23:39:43,864 INFO MainThread:43269 [wandb_run.py:_footer_history_summary_info():4026] rendering summary +2024-05-25 23:39:43,866 INFO MainThread:43269 [wandb_run.py:_footer_sync_info():3953] logging synced files diff --git a/runseed5/wandb/run-20240525_214643-cngfo6vp/run-cngfo6vp.wandb b/runseed5/wandb/run-20240525_214643-cngfo6vp/run-cngfo6vp.wandb new file mode 100644 index 0000000000000000000000000000000000000000..dec144687e3c1a1f67879e1b4263c448e0b54d48 Binary files /dev/null and b/runseed5/wandb/run-20240525_214643-cngfo6vp/run-cngfo6vp.wandb differ diff --git a/runseed99/args.yaml b/runseed99/args.yaml new file mode 100644 index 0000000000000000000000000000000000000000..f12a204641ca40eb2831500dedf9463856c018ff --- /dev/null +++ b/runseed99/args.yaml @@ -0,0 +1,42 @@ +batch_size: 2 +checkpoint: true +ckpt_freq: 100 +ckpt_only_lora: false +data: + data: '' + eval_instruct_data: '' + instruct: + dynamic_chunk_fn_call: true + shuffle: true + instruct_data: /root/data/mol_instructions_train.jsonl + shuffle: false +eval_freq: 100 +log_freq: 1 +lora: + dropout: 0.0 + enable: true + rank: 64 + scaling: 2.0 +max_norm: 1.0 +max_steps: 500 +mlflow: + experiment_name: null + tracking_uri: null +model_id_or_path: /root/mistral_models/7B-v0.3 +no_ckpt: false +no_eval: true +num_ckpt_keep: 3 +num_microbatches: 1 +optim: + lr: 5.0e-05 + pct_start: 0.05 + weight_decay: 0.05 +run_dir: /root/mistral-finetune/runseed99 +seed: 99 +seq_len: 32768 +wandb: + key: aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df + offline: false + project: CHEMISTral7b-ft + run_name: runseed99 +world_size: 1 diff --git a/runseed99/tb/events.out.tfevents.1716687993.scw-tender-archimedes.66405.0.train b/runseed99/tb/events.out.tfevents.1716687993.scw-tender-archimedes.66405.0.train new file mode 100644 index 0000000000000000000000000000000000000000..038343a0587384ce06a1b33a1def7a6d7d07ce1d --- /dev/null +++ b/runseed99/tb/events.out.tfevents.1716687993.scw-tender-archimedes.66405.0.train @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:afbc27ed7f6394a4c8ffedfc2106d76c6ab6ef56c7f14fc3e639931ad2ff9098 +size 88 diff --git a/runseed99/tb/events.out.tfevents.1716687996.scw-tender-archimedes.66405.1.eval b/runseed99/tb/events.out.tfevents.1716687996.scw-tender-archimedes.66405.1.eval new file mode 100644 index 0000000000000000000000000000000000000000..82b97b2b7f2af9035a4f4b05963abcff1830293c --- /dev/null +++ b/runseed99/tb/events.out.tfevents.1716687996.scw-tender-archimedes.66405.1.eval @@ -0,0 +1,3 @@ +version https://git-lfs.github.com/spec/v1 +oid sha256:912853867bc3b153dca254521b49ba5743329500cae23e90e196990a85117452 +size 88 diff --git a/runseed99/wandb/debug-internal.log b/runseed99/wandb/debug-internal.log new file mode 120000 index 0000000000000000000000000000000000000000..5ef801fe666f5dc3c54d7db0ce56e93bedc97a97 --- /dev/null +++ b/runseed99/wandb/debug-internal.log @@ -0,0 +1 @@ +run-20240526_014634-8idqp8iz/logs/debug-internal.log \ No newline at end of file diff --git a/runseed99/wandb/debug.log b/runseed99/wandb/debug.log new file mode 120000 index 0000000000000000000000000000000000000000..0f5178b5925e2da69cd07bd5c4442cdfa22a6dba --- /dev/null +++ b/runseed99/wandb/debug.log @@ -0,0 +1 @@ +run-20240526_014634-8idqp8iz/logs/debug.log \ No newline at end of file diff --git a/runseed99/wandb/latest-run b/runseed99/wandb/latest-run new file mode 120000 index 0000000000000000000000000000000000000000..9e2095e2d5f68b4d5a9b35c757a2e1263af8e659 --- /dev/null +++ b/runseed99/wandb/latest-run @@ -0,0 +1 @@ +run-20240526_014634-8idqp8iz \ No newline at end of file diff --git a/runseed99/wandb/run-20240526_014634-8idqp8iz/files/conda-environment.yaml b/runseed99/wandb/run-20240526_014634-8idqp8iz/files/conda-environment.yaml new file mode 100644 index 0000000000000000000000000000000000000000..ab0adee1bc32623698cb076e678310ba5d50e791 --- /dev/null +++ b/runseed99/wandb/run-20240526_014634-8idqp8iz/files/conda-environment.yaml @@ -0,0 +1,128 @@ +name: chemistralpy310 +channels: + - conda-forge + - defaults +dependencies: + - _libgcc_mutex=0.1=conda_forge + - _openmp_mutex=4.5=2_gnu + - asttokens=2.4.1=pyhd8ed1ab_0 + - bzip2=1.0.8=h5eee18b_6 + - ca-certificates=2024.3.11=h06a4308_0 + - comm=0.2.2=pyhd8ed1ab_0 + - debugpy=1.6.7=py310h6a678d5_0 + - decorator=5.1.1=pyhd8ed1ab_0 + - exceptiongroup=1.2.0=pyhd8ed1ab_2 + - executing=2.0.1=pyhd8ed1ab_0 + - importlib-metadata=7.1.0=pyha770c72_0 + - importlib_metadata=7.1.0=hd8ed1ab_0 + - ipykernel=6.29.3=pyhd33586a_0 + - ipython=8.24.0=pyh707e725_0 + - jedi=0.19.1=pyhd8ed1ab_0 + - jupyter_client=8.6.2=pyhd8ed1ab_0 + - jupyter_core=5.7.2=py310hff52083_0 + - ld_impl_linux-64=2.38=h1181459_1 + - libffi=3.4.4=h6a678d5_1 + - libgcc-ng=13.2.0=h77fa898_7 + - libgomp=13.2.0=h77fa898_7 + - libsodium=1.0.18=h36c2ea0_1 + - libstdcxx-ng=11.2.0=h1234567_1 + - libuuid=1.41.5=h5eee18b_0 + - matplotlib-inline=0.1.7=pyhd8ed1ab_0 + - ncurses=6.4=h6a678d5_0 + - nest-asyncio=1.6.0=pyhd8ed1ab_0 + - openssl=3.3.0=h4ab18f5_3 + - packaging=24.0=pyhd8ed1ab_0 + - parso=0.8.4=pyhd8ed1ab_0 + - pexpect=4.9.0=pyhd8ed1ab_0 + - pickleshare=0.7.5=py_1003 + - pip=24.0=py310h06a4308_0 + - platformdirs=4.2.2=pyhd8ed1ab_0 + - prompt-toolkit=3.0.42=pyha770c72_0 + - psutil=5.9.8=py310h2372a71_0 + - ptyprocess=0.7.0=pyhd3deb0d_0 + - pure_eval=0.2.2=pyhd8ed1ab_0 + - pygments=2.18.0=pyhd8ed1ab_0 + - python=3.10.14=h955ad1f_1 + - python-dateutil=2.9.0=pyhd8ed1ab_0 + - python_abi=3.10=2_cp310 + - pyzmq=25.1.2=py310h6a678d5_0 + - readline=8.2=h5eee18b_0 + - setuptools=69.5.1=py310h06a4308_0 + - six=1.16.0=pyh6c4a22f_0 + - sqlite=3.45.3=h5eee18b_0 + - stack_data=0.6.2=pyhd8ed1ab_0 + - tk=8.6.14=h39e8969_0 + - tornado=6.4=py310h2372a71_0 + - traitlets=5.14.3=pyhd8ed1ab_0 + - typing_extensions=4.11.0=pyha770c72_0 + - tzdata=2024a=h04d1e81_0 + - wcwidth=0.2.13=pyhd8ed1ab_0 + - wheel=0.43.0=py310h06a4308_0 + - xz=5.4.6=h5eee18b_1 + - zeromq=4.3.5=h6a678d5_0 + - zipp=3.17.0=pyhd8ed1ab_0 + - zlib=1.2.13=h5eee18b_1 + - pip: + - absl-py==2.1.0 + - annotated-types==0.7.0 + - attrs==23.2.0 + - certifi==2024.2.2 + - charset-normalizer==3.3.2 + - click==8.1.7 + - docker-pycreds==0.4.0 + - docstring-parser==0.16 + - filelock==3.14.0 + - fire==0.6.0 + - fsspec==2024.5.0 + - gitdb==4.0.11 + - gitpython==3.1.43 + - grpcio==1.64.0 + - huggingface-hub==0.23.1 + - idna==3.7 + - jinja2==3.1.4 + - jsonschema==4.21.1 + - jsonschema-specifications==2023.12.1 + - markdown==3.6 + - markupsafe==2.1.5 + - mistral-common==1.1.0 + - mpmath==1.3.0 + - networkx==3.3 + - numpy==1.26.4 + - nvidia-cublas-cu12==12.1.3.1 + - nvidia-cuda-cupti-cu12==12.1.105 + - nvidia-cuda-nvrtc-cu12==12.1.105 + - nvidia-cuda-runtime-cu12==12.1.105 + - nvidia-cudnn-cu12==8.9.2.26 + - nvidia-cufft-cu12==11.0.2.54 + - nvidia-curand-cu12==10.3.2.106 + - nvidia-cusolver-cu12==11.4.5.107 + - nvidia-cusparse-cu12==12.1.0.106 + - nvidia-nccl-cu12==2.19.3 + - nvidia-nvjitlink-cu12==12.5.40 + - nvidia-nvtx-cu12==12.1.105 + - protobuf==4.25.3 + - pydantic==2.6.1 + - pydantic-core==2.16.2 + - pyyaml==6.0.1 + - referencing==0.35.1 + - requests==2.32.2 + - rpds-py==0.18.1 + - safetensors==0.4.3 + - sentencepiece==0.1.99 + - sentry-sdk==2.3.1 + - setproctitle==1.3.3 + - simple-parsing==0.1.5 + - smmap==5.0.1 + - sympy==1.12 + - tensorboard==2.16.2 + - tensorboard-data-server==0.7.2 + - termcolor==2.4.0 + - torch==2.2.0 + - tqdm==4.66.4 + - triton==2.2.0 + - typing-extensions==4.12.0 + - urllib3==2.2.1 + - wandb==0.17.0 + - werkzeug==3.0.3 + - xformers==0.0.24 +prefix: /root/miniconda/envs/chemistralpy310 diff --git a/runseed99/wandb/run-20240526_014634-8idqp8iz/files/config.yaml b/runseed99/wandb/run-20240526_014634-8idqp8iz/files/config.yaml new file mode 100644 index 0000000000000000000000000000000000000000..7709fd81ac29f7189027a57de5b46184e86e44e3 --- /dev/null +++ b/runseed99/wandb/run-20240526_014634-8idqp8iz/files/config.yaml @@ -0,0 +1,113 @@ +wandb_version: 1 + +data: + desc: null + value: + data: '' + shuffle: false + instruct_data: /root/data/mol_instructions_train.jsonl + eval_instruct_data: '' + instruct: + shuffle: true + dynamic_chunk_fn_call: true +model_id_or_path: + desc: null + value: /root/mistral_models/7B-v0.3 +run_dir: + desc: null + value: /root/mistral-finetune/runseed99 +optim: + desc: null + value: + lr: 5.0e-05 + weight_decay: 0.05 + pct_start: 0.05 +seed: + desc: null + value: 99 +num_microbatches: + desc: null + value: 1 +seq_len: + desc: null + value: 32768 +batch_size: + desc: null + value: 2 +max_norm: + desc: null + value: 1.0 +max_steps: + desc: null + value: 500 +log_freq: + desc: null + value: 1 +ckpt_freq: + desc: null + value: 100 +ckpt_only_lora: + desc: null + value: false +no_ckpt: + desc: null + value: false +num_ckpt_keep: + desc: null + value: 3 +eval_freq: + desc: null + value: 100 +no_eval: + desc: null + value: true +checkpoint: + desc: null + value: true +world_size: + desc: null + value: 1 +wandb: + desc: null + value: + project: CHEMISTral7b-ft + offline: false + key: aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df + run_name: runseed99 +mlflow: + desc: null + value: + tracking_uri: null + experiment_name: null +lora: + desc: null + value: + enable: true + rank: 64 + dropout: 0.0 + scaling: 2.0 +_wandb: + desc: null + value: + python_version: 3.10.14 + cli_version: 0.17.0 + framework: torch + is_jupyter_run: false + is_kaggle_kernel: false + start_time: 1716687994 + t: + 1: + - 1 + - 55 + 2: + - 1 + - 55 + 3: + - 13 + - 16 + - 23 + 4: 3.10.14 + 5: 0.17.0 + 8: + - 5 + 13: linux-x86_64 diff --git a/runseed99/wandb/run-20240526_014634-8idqp8iz/files/output.log b/runseed99/wandb/run-20240526_014634-8idqp8iz/files/output.log new file mode 100644 index 0000000000000000000000000000000000000000..cdd3050b8c9bd6d6630a157664f82624a6aba7aa --- /dev/null +++ b/runseed99/wandb/run-20240526_014634-8idqp8iz/files/output.log @@ -0,0 +1,10 @@ + +wandb: WARNING Calling wandb.login() after wandb.init() has no effect. +2024-05-26 01:46:36 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Reloading model from /root/mistral_models/7B-v0.3/consolidated.safetensors ... +2024-05-26 01:46:36 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Converting model to dtype torch.bfloat16 ... +2024-05-26 01:46:36 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Loaded model on cpu! +2024-05-26 01:46:36 (UTC) - 0:00:04 - finetune.wrapped_model - INFO - Initializing lora layers ... +2024-05-26 01:46:36 (UTC) - 0:00:05 - finetune.wrapped_model - INFO - Finished initialization! +2024-05-26 01:46:36 (UTC) - 0:00:05 - finetune.wrapped_model - INFO - Sharding model over 1 GPUs ... +2024-05-26 01:46:38 (UTC) - 0:00:06 - finetune.wrapped_model - INFO - Model sharded! +2024-05-26 01:46:38 (UTC) - 0:00:06 - finetune.wrapped_model - INFO - 167,772,160 out of 7,415,795,712 parameter are finetuned (2.26%). diff --git a/runseed99/wandb/run-20240526_014634-8idqp8iz/files/requirements.txt b/runseed99/wandb/run-20240526_014634-8idqp8iz/files/requirements.txt new file mode 100644 index 0000000000000000000000000000000000000000..d0f2d0023c697fd324e55391a29f7c9ad69480f6 --- /dev/null +++ b/runseed99/wandb/run-20240526_014634-8idqp8iz/files/requirements.txt @@ -0,0 +1,98 @@ +GitPython==3.1.43 +Jinja2==3.1.4 +Markdown==3.6 +MarkupSafe==2.1.5 +PyYAML==6.0.1 +Pygments==2.18.0 +Werkzeug==3.0.3 +absl-py==2.1.0 +annotated-types==0.7.0 +asttokens==2.4.1 +attrs==23.2.0 +certifi==2024.2.2 +charset-normalizer==3.3.2 +click==8.1.7 +comm==0.2.2 +debugpy==1.6.7 +decorator==5.1.1 +docker-pycreds==0.4.0 +docstring_parser==0.16 +exceptiongroup==1.2.0 +executing==2.0.1 +filelock==3.14.0 +fire==0.6.0 +fsspec==2024.5.0 +gitdb==4.0.11 +grpcio==1.64.0 +huggingface-hub==0.23.1 +idna==3.7 +importlib_metadata==7.1.0 +ipykernel==6.29.3 +ipython==8.24.0 +jedi==0.19.1 +jsonschema-specifications==2023.12.1 +jsonschema==4.21.1 +jupyter_client==8.6.2 +jupyter_core==5.7.2 +matplotlib-inline==0.1.7 +mistral_common==1.1.0 +mpmath==1.3.0 +nest_asyncio==1.6.0 +networkx==3.3 +numpy==1.26.4 +nvidia-cublas-cu12==12.1.3.1 +nvidia-cuda-cupti-cu12==12.1.105 +nvidia-cuda-nvrtc-cu12==12.1.105 +nvidia-cuda-runtime-cu12==12.1.105 +nvidia-cudnn-cu12==8.9.2.26 +nvidia-cufft-cu12==11.0.2.54 +nvidia-curand-cu12==10.3.2.106 +nvidia-cusolver-cu12==11.4.5.107 +nvidia-cusparse-cu12==12.1.0.106 +nvidia-nccl-cu12==2.19.3 +nvidia-nvjitlink-cu12==12.5.40 +nvidia-nvtx-cu12==12.1.105 +packaging==24.0 +parso==0.8.4 +pexpect==4.9.0 +pickleshare==0.7.5 +pip==24.0 +platformdirs==4.2.2 +prompt-toolkit==3.0.42 +protobuf==4.25.3 +psutil==5.9.8 +ptyprocess==0.7.0 +pure-eval==0.2.2 +pydantic==2.6.1 +pydantic_core==2.16.2 +python-dateutil==2.9.0 +pyzmq==25.1.2 +referencing==0.35.1 +requests==2.32.2 +rpds-py==0.18.1 +safetensors==0.4.3 +sentencepiece==0.1.99 +sentry-sdk==2.3.1 +setproctitle==1.3.3 +setuptools==69.5.1 +simple_parsing==0.1.5 +six==1.16.0 +smmap==5.0.1 +stack-data==0.6.2 +sympy==1.12 +tensorboard-data-server==0.7.2 +tensorboard==2.16.2 +termcolor==2.4.0 +torch==2.2.0 +tornado==6.4 +tqdm==4.66.4 +traitlets==5.14.3 +triton==2.2.0 +typing_extensions==4.11.0 +typing_extensions==4.12.0 +urllib3==2.2.1 +wandb==0.17.0 +wcwidth==0.2.13 +wheel==0.43.0 +xformers==0.0.24 +zipp==3.17.0 \ No newline at end of file diff --git a/runseed99/wandb/run-20240526_014634-8idqp8iz/files/wandb-metadata.json b/runseed99/wandb/run-20240526_014634-8idqp8iz/files/wandb-metadata.json new file mode 100644 index 0000000000000000000000000000000000000000..6dba49936eff9de819e626013730de7731578a68 --- /dev/null +++ b/runseed99/wandb/run-20240526_014634-8idqp8iz/files/wandb-metadata.json @@ -0,0 +1,169 @@ +{ + "os": "Linux-5.15.0-102-generic-x86_64-with-glibc2.35", + "python": "3.10.14", + "heartbeatAt": "2024-05-26T01:46:35.048516", + "startedAt": "2024-05-26T01:46:34.618807", + "docker": null, + "cuda": null, + "args": [ + "example/7B.yaml" + ], + "state": "running", + "program": "-m train", + "codePathLocal": null, + "git": { + "remote": "https://github.com/mistralai/mistral-finetune.git", + "commit": "cb892f012ef940bc741dd3b043bc1d06f0cf6085" + }, + "email": "clement.castellon@gmail.com", + "root": "/root/mistral-finetune", + "host": "scw-tender-archimedes", + "username": "root", + "executable": "/root/miniconda/envs/chemistralpy310/bin/python", + "cpu_count": 24, + "cpu_count_logical": 24, + "cpu_freq": { + "current": 2699.9959999999996, + "min": 0.0, + "max": 0.0 + }, + "cpu_freq_per_core": [ + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + }, + { + "current": 2699.996, + "min": 0.0, + "max": 0.0 + } + ], + "disk": { + "/": { + "total": 902.4293403625488, + "used": 271.7768363952637 + } + }, + "gpu": "NVIDIA H100 PCIe", + "gpu_count": 1, + "gpu_devices": [ + { + "name": "NVIDIA H100 PCIe", + "memory_total": 85520809984 + } + ], + "memory": { + "total": 235.9408187866211 + } +} diff --git a/runseed99/wandb/run-20240526_014634-8idqp8iz/logs/debug-internal.log b/runseed99/wandb/run-20240526_014634-8idqp8iz/logs/debug-internal.log new file mode 100644 index 0000000000000000000000000000000000000000..267c8201239b0ed87eb5fc16adf3e2fe89a13b72 --- /dev/null +++ b/runseed99/wandb/run-20240526_014634-8idqp8iz/logs/debug-internal.log @@ -0,0 +1,256 @@ +2024-05-26 01:46:34,621 INFO StreamThr :66459 [internal.py:wandb_internal():85] W&B internal server running at pid: 66459, started at: 2024-05-26 01:46:34.621313 +2024-05-26 01:46:34,622 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status +2024-05-26 01:46:34,625 INFO WriterThread:66459 [datastore.py:open_for_write():87] open: /root/mistral-finetune/runseed99/wandb/run-20240526_014634-8idqp8iz/run-8idqp8iz.wandb +2024-05-26 01:46:34,625 DEBUG SenderThread:66459 [sender.py:send():378] send: header +2024-05-26 01:46:34,625 DEBUG SenderThread:66459 [sender.py:send():378] send: run +2024-05-26 01:46:34,964 INFO SenderThread:66459 [dir_watcher.py:__init__():211] watching files in: /root/mistral-finetune/runseed99/wandb/run-20240526_014634-8idqp8iz/files +2024-05-26 01:46:34,965 INFO SenderThread:66459 [sender.py:_start_run_threads():1123] run started: 8idqp8iz with start time 1716687994.621104 +2024-05-26 01:46:34,969 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: check_version +2024-05-26 01:46:34,969 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: check_version +2024-05-26 01:46:35,030 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: run_start +2024-05-26 01:46:35,036 DEBUG HandlerThread:66459 [system_info.py:__init__():26] System info init +2024-05-26 01:46:35,036 DEBUG HandlerThread:66459 [system_info.py:__init__():41] System info init done +2024-05-26 01:46:35,036 INFO HandlerThread:66459 [system_monitor.py:start():194] Starting system monitor +2024-05-26 01:46:35,036 INFO SystemMonitor:66459 [system_monitor.py:_start():158] Starting system asset monitoring threads +2024-05-26 01:46:35,036 INFO HandlerThread:66459 [system_monitor.py:probe():214] Collecting system info +2024-05-26 01:46:35,036 INFO SystemMonitor:66459 [interfaces.py:start():188] Started cpu monitoring +2024-05-26 01:46:35,037 INFO SystemMonitor:66459 [interfaces.py:start():188] Started disk monitoring +2024-05-26 01:46:35,038 INFO SystemMonitor:66459 [interfaces.py:start():188] Started gpu monitoring +2024-05-26 01:46:35,039 INFO SystemMonitor:66459 [interfaces.py:start():188] Started memory monitoring +2024-05-26 01:46:35,040 INFO SystemMonitor:66459 [interfaces.py:start():188] Started network monitoring +2024-05-26 01:46:35,048 DEBUG HandlerThread:66459 [system_info.py:probe():150] Probing system +2024-05-26 01:46:35,049 DEBUG HandlerThread:66459 [system_info.py:_probe_git():135] Probing git +2024-05-26 01:46:35,053 DEBUG HandlerThread:66459 [system_info.py:_probe_git():143] Probing git done +2024-05-26 01:46:35,053 DEBUG HandlerThread:66459 [system_info.py:probe():198] Probing system done +2024-05-26 01:46:35,053 DEBUG HandlerThread:66459 [system_monitor.py:probe():223] {'os': 'Linux-5.15.0-102-generic-x86_64-with-glibc2.35', 'python': '3.10.14', 'heartbeatAt': '2024-05-26T01:46:35.048516', 'startedAt': '2024-05-26T01:46:34.618807', 'docker': None, 'cuda': None, 'args': ('example/7B.yaml',), 'state': 'running', 'program': '-m train', 'codePathLocal': None, 'git': {'remote': 'https://github.com/mistralai/mistral-finetune.git', 'commit': 'cb892f012ef940bc741dd3b043bc1d06f0cf6085'}, 'email': 'clement.castellon@gmail.com', 'root': '/root/mistral-finetune', 'host': 'scw-tender-archimedes', 'username': 'root', 'executable': '/root/miniconda/envs/chemistralpy310/bin/python', 'cpu_count': 24, 'cpu_count_logical': 24, 'cpu_freq': {'current': 2699.9959999999996, 'min': 0.0, 'max': 0.0}, 'cpu_freq_per_core': [{'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}, {'current': 2699.996, 'min': 0.0, 'max': 0.0}], 'disk': {'/': {'total': 902.4293403625488, 'used': 271.7768363952637}}, 'gpu': 'NVIDIA H100 PCIe', 'gpu_count': 1, 'gpu_devices': [{'name': 'NVIDIA H100 PCIe', 'memory_total': 85520809984}], 'memory': {'total': 235.9408187866211}} +2024-05-26 01:46:35,053 INFO HandlerThread:66459 [system_monitor.py:probe():224] Finished collecting system info +2024-05-26 01:46:35,053 INFO HandlerThread:66459 [system_monitor.py:probe():227] Publishing system info +2024-05-26 01:46:35,053 DEBUG HandlerThread:66459 [system_info.py:_save_conda():207] Saving list of conda packages installed into the current environment +2024-05-26 01:46:35,965 INFO Thread-12 :66459 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runseed99/wandb/run-20240526_014634-8idqp8iz/files/conda-environment.yaml +2024-05-26 01:46:36,068 DEBUG HandlerThread:66459 [system_info.py:_save_conda():222] Saving conda packages done +2024-05-26 01:46:36,068 INFO HandlerThread:66459 [system_monitor.py:probe():229] Finished publishing system info +2024-05-26 01:46:36,071 DEBUG SenderThread:66459 [sender.py:send():378] send: files +2024-05-26 01:46:36,071 INFO SenderThread:66459 [sender.py:_save_file():1389] saving file wandb-metadata.json with policy now +2024-05-26 01:46:36,108 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: python_packages +2024-05-26 01:46:36,108 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:46:36,108 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: python_packages +2024-05-26 01:46:36,109 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:46:36,300 DEBUG SenderThread:66459 [sender.py:send():378] send: telemetry +2024-05-26 01:46:36,544 INFO wandb-upload_0:66459 [upload_job.py:push():130] Uploaded file /tmp/tmp0jd4kct2wandb/evphydmy-wandb-metadata.json +2024-05-26 01:46:36,965 INFO Thread-12 :66459 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed99/wandb/run-20240526_014634-8idqp8iz/files/conda-environment.yaml +2024-05-26 01:46:36,965 INFO Thread-12 :66459 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runseed99/wandb/run-20240526_014634-8idqp8iz/files/wandb-metadata.json +2024-05-26 01:46:36,966 INFO Thread-12 :66459 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runseed99/wandb/run-20240526_014634-8idqp8iz/files/output.log +2024-05-26 01:46:36,966 INFO Thread-12 :66459 [dir_watcher.py:_on_file_created():271] file/dir created: /root/mistral-finetune/runseed99/wandb/run-20240526_014634-8idqp8iz/files/requirements.txt +2024-05-26 01:46:38,966 INFO Thread-12 :66459 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed99/wandb/run-20240526_014634-8idqp8iz/files/output.log +2024-05-26 01:46:40,207 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:46:45,207 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:46:50,208 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:46:51,108 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:46:51,109 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:46:55,314 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:47:00,314 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:47:05,317 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:47:05,972 INFO Thread-12 :66459 [dir_watcher.py:_on_file_modified():288] file/dir modified: /root/mistral-finetune/runseed99/wandb/run-20240526_014634-8idqp8iz/files/config.yaml +2024-05-26 01:47:06,109 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:47:06,109 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:47:11,284 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:47:16,285 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:47:21,149 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:47:21,150 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:47:22,283 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:47:27,284 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:47:32,285 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:47:35,040 DEBUG SystemMonitor:66459 [system_monitor.py:_start():172] Starting system metrics aggregation loop +2024-05-26 01:47:35,041 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:47:36,175 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:47:36,175 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:47:37,367 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:47:42,367 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:47:47,368 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:47:51,167 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:47:51,167 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:47:53,326 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:47:58,327 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:48:03,327 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:48:05,042 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:48:06,135 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:48:06,135 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:48:09,287 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:48:14,288 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:48:19,289 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:48:21,156 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:48:21,156 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:48:24,381 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:48:29,382 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:48:34,383 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:48:35,042 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:48:36,182 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:48:36,182 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:48:40,322 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:48:45,322 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:48:50,323 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:48:51,198 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:48:51,198 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:48:55,427 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:49:00,428 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:49:05,042 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:49:06,043 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:49:06,219 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:49:06,220 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:49:11,343 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:49:16,344 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:49:21,214 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:49:21,214 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:49:21,368 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:49:26,369 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:49:31,370 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:49:35,043 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:49:36,210 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:49:36,210 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:49:36,387 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:49:41,388 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:49:46,389 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:49:51,215 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:49:51,216 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:49:51,444 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:49:56,444 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:50:01,445 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:50:05,044 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:50:06,199 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:50:06,199 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:50:07,352 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:50:12,353 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:50:17,353 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:50:21,241 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:50:21,242 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:50:22,419 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:50:27,420 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:50:32,420 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:50:35,044 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:50:36,210 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:50:36,210 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:50:38,378 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:50:43,379 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:50:48,380 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:50:51,227 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:50:51,227 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:50:53,451 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:50:58,452 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:51:03,453 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:51:05,045 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:51:06,231 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:51:06,232 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:51:09,368 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:51:14,369 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:51:19,370 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:51:21,263 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:51:21,264 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:51:24,395 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:51:29,396 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:51:34,396 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:51:35,045 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:51:36,248 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:51:36,249 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:51:39,469 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:51:44,470 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:51:49,470 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:51:51,279 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:51:51,279 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:51:55,424 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:52:00,425 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:52:05,046 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:52:06,046 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:52:06,285 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:52:06,285 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:52:11,427 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:52:16,428 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:52:21,309 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:52:21,310 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:52:21,539 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:52:26,540 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:52:31,540 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:52:35,046 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:52:36,300 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:52:36,300 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:52:37,522 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:52:42,522 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:52:47,523 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:52:51,305 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:52:51,305 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:52:52,540 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:52:57,540 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:53:02,541 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:53:05,046 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:53:06,294 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:53:06,294 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:53:08,449 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:53:13,449 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:53:18,450 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:53:21,304 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:53:21,305 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:53:23,503 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:53:28,504 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:53:33,504 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:53:35,047 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:53:36,310 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:53:36,310 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:53:39,437 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:53:44,438 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:53:49,439 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:53:51,312 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:53:51,313 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:53:54,481 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:53:59,482 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:54:04,483 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:54:05,047 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:54:06,328 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:54:06,328 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:54:09,505 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:54:14,506 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:54:19,507 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:54:21,328 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:54:21,328 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:54:25,475 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:54:30,475 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:54:35,048 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:54:36,049 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:54:36,338 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:54:36,338 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:54:41,494 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:54:46,495 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:54:51,339 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:54:51,339 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:54:51,586 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:54:56,586 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:55:01,587 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:55:05,048 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:55:06,333 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:55:06,334 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:55:07,465 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:55:12,466 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:55:17,467 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:55:21,349 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:55:21,350 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:55:22,579 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:55:27,579 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:55:32,580 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:55:35,049 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:55:36,350 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:55:36,350 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:55:38,557 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:55:43,557 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:55:48,558 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:55:51,370 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:55:51,371 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:55:53,592 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:55:58,593 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:56:03,594 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:56:05,050 DEBUG SenderThread:66459 [sender.py:send():378] send: stats +2024-05-26 01:56:06,369 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:56:06,369 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:56:09,512 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:56:14,512 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:56:19,513 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report +2024-05-26 01:56:21,369 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: stop_status +2024-05-26 01:56:21,370 DEBUG SenderThread:66459 [sender.py:send_request():405] send_request: stop_status +2024-05-26 01:56:24,601 DEBUG HandlerThread:66459 [handler.py:handle_request():158] handle_request: status_report diff --git a/runseed99/wandb/run-20240526_014634-8idqp8iz/logs/debug.log b/runseed99/wandb/run-20240526_014634-8idqp8iz/logs/debug.log new file mode 100644 index 0000000000000000000000000000000000000000..1dfd30d06345b9f8ba9654d1ad30a29e8b26d138 --- /dev/null +++ b/runseed99/wandb/run-20240526_014634-8idqp8iz/logs/debug.log @@ -0,0 +1,29 @@ +2024-05-26 01:46:34,619 INFO MainThread:66405 [wandb_setup.py:_flush():76] Current SDK version is 0.17.0 +2024-05-26 01:46:34,619 INFO MainThread:66405 [wandb_setup.py:_flush():76] Configure stats pid to 66405 +2024-05-26 01:46:34,619 INFO MainThread:66405 [wandb_setup.py:_flush():76] Loading settings from /root/.config/wandb/settings +2024-05-26 01:46:34,619 INFO MainThread:66405 [wandb_setup.py:_flush():76] Loading settings from /root/mistral-finetune/wandb/settings +2024-05-26 01:46:34,619 INFO MainThread:66405 [wandb_setup.py:_flush():76] Loading settings from environment variables: {} +2024-05-26 01:46:34,619 WARNING MainThread:66405 [wandb_setup.py:_flush():76] Could not find program at -m train +2024-05-26 01:46:34,619 INFO MainThread:66405 [wandb_setup.py:_flush():76] Inferring run settings from compute environment: {'program_relpath': None, 'program': '-m train'} +2024-05-26 01:46:34,619 INFO MainThread:66405 [wandb_setup.py:_flush():76] Applying login settings: {'api_key': '***REDACTED***'} +2024-05-26 01:46:34,619 INFO MainThread:66405 [wandb_setup.py:_flush():76] Applying login settings: {'api_key': '***REDACTED***'} +2024-05-26 01:46:34,619 INFO MainThread:66405 [wandb_setup.py:_flush():76] Applying login settings: {} +2024-05-26 01:46:34,619 INFO MainThread:66405 [wandb_init.py:_log_setup():520] Logging user logs to /root/mistral-finetune/runseed99/wandb/run-20240526_014634-8idqp8iz/logs/debug.log +2024-05-26 01:46:34,619 INFO MainThread:66405 [wandb_init.py:_log_setup():521] Logging internal logs to /root/mistral-finetune/runseed99/wandb/run-20240526_014634-8idqp8iz/logs/debug-internal.log +2024-05-26 01:46:34,619 INFO MainThread:66405 [wandb_init.py:init():560] calling init triggers +2024-05-26 01:46:34,619 INFO MainThread:66405 [wandb_init.py:init():567] wandb.init called with sweep_config: {} +config: {'data': {'data': '', 'shuffle': False, 'instruct_data': '/root/data/mol_instructions_train.jsonl', 'eval_instruct_data': '', 'instruct': {'shuffle': True, 'dynamic_chunk_fn_call': True}}, 'model_id_or_path': '/root/mistral_models/7B-v0.3', 'run_dir': '/root/mistral-finetune/runseed99', 'optim': {'lr': 5e-05, 'weight_decay': 0.05, 'pct_start': 0.05}, 'seed': 99, 'num_microbatches': 1, 'seq_len': 32768, 'batch_size': 2, 'max_norm': 1.0, 'max_steps': 500, 'log_freq': 1, 'ckpt_freq': 100, 'ckpt_only_lora': False, 'no_ckpt': False, 'num_ckpt_keep': 3, 'eval_freq': 100, 'no_eval': True, 'checkpoint': True, 'world_size': 1, 'wandb': {'project': 'CHEMISTral7b-ft', 'offline': False, 'key': 'aaf77f83a4e316f6a8b47fa975ab6b5e73c7c8df', 'run_name': 'runseed99'}, 'mlflow': {'tracking_uri': None, 'experiment_name': None}, 'lora': {'enable': True, 'rank': 64, 'dropout': 0.0, 'scaling': 2.0}} +2024-05-26 01:46:34,619 INFO MainThread:66405 [wandb_init.py:init():610] starting backend +2024-05-26 01:46:34,619 INFO MainThread:66405 [wandb_init.py:init():614] setting up manager +2024-05-26 01:46:34,620 INFO MainThread:66405 [backend.py:_multiprocessing_setup():105] multiprocessing start_methods=fork,spawn,forkserver, using: spawn +2024-05-26 01:46:34,621 INFO MainThread:66405 [wandb_init.py:init():622] backend started and connected +2024-05-26 01:46:34,622 INFO MainThread:66405 [wandb_init.py:init():711] updated telemetry +2024-05-26 01:46:34,624 INFO MainThread:66405 [wandb_init.py:init():744] communicating run to backend with 90.0 second timeout +2024-05-26 01:46:34,969 INFO MainThread:66405 [wandb_run.py:_on_init():2396] communicating current version +2024-05-26 01:46:34,984 INFO MainThread:66405 [wandb_run.py:_on_init():2405] got version response +2024-05-26 01:46:34,984 INFO MainThread:66405 [wandb_init.py:init():795] starting run threads in backend +2024-05-26 01:46:36,108 INFO MainThread:66405 [wandb_run.py:_console_start():2374] atexit reg +2024-05-26 01:46:36,109 INFO MainThread:66405 [wandb_run.py:_redirect():2229] redirect: wrap_raw +2024-05-26 01:46:36,109 INFO MainThread:66405 [wandb_run.py:_redirect():2294] Wrapping output streams. +2024-05-26 01:46:36,109 INFO MainThread:66405 [wandb_run.py:_redirect():2319] Redirects installed. +2024-05-26 01:46:36,109 INFO MainThread:66405 [wandb_init.py:init():838] run started, returning control to user process diff --git a/runseed99/wandb/run-20240526_014634-8idqp8iz/run-8idqp8iz.wandb b/runseed99/wandb/run-20240526_014634-8idqp8iz/run-8idqp8iz.wandb new file mode 100644 index 0000000000000000000000000000000000000000..4439bad1be8ee886d6a212bd3d0e58282af25459 Binary files /dev/null and b/runseed99/wandb/run-20240526_014634-8idqp8iz/run-8idqp8iz.wandb differ diff --git a/tests/__init__.py b/tests/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/tests/fixtures b/tests/fixtures new file mode 120000 index 0000000000000000000000000000000000000000..8b137891791fe96927ad78e64b0aad7bded08bdc --- /dev/null +++ b/tests/fixtures @@ -0,0 +1 @@ + diff --git a/tests/test_checkpointer.py b/tests/test_checkpointer.py new file mode 100644 index 0000000000000000000000000000000000000000..f8eef34c2ce38fd002e7802563ad9545cda03a18 --- /dev/null +++ b/tests/test_checkpointer.py @@ -0,0 +1,212 @@ +from pathlib import Path + +import pytest +import torch + +from finetune.args import LoraArgs +from finetune.checkpointing import Checkpointer +from finetune.utils import TrainState +from finetune.wrapped_model import load_model +from tests.test_utils import MODEL_PATH, is_float_equal, setup_mp_test_dist +from utils.merge_lora import merge_checkpoints + +from .test_utils import spawn_for_all_world_sizes + +# fmt: off +EXPECTED_NON_LORA_KEYS = sorted(['layers.0.attention.wk.weight', 'layers.0.attention.wo.weight', 'layers.0.attention.wq.weight', 'layers.0.attention.wv.weight', 'layers.0.attention_norm.weight', 'layers.0.feed_forward.w1.weight', 'layers.0.feed_forward.w2.weight', 'layers.0.feed_forward.w3.weight', 'layers.0.ffn_norm.weight', 'layers.1.attention.wk.weight', 'layers.1.attention.wo.weight', 'layers.1.attention.wq.weight', 'layers.1.attention.wv.weight', 'layers.1.attention_norm.weight', 'layers.1.feed_forward.w1.weight', 'layers.1.feed_forward.w2.weight', 'layers.1.feed_forward.w3.weight', 'layers.1.ffn_norm.weight', 'norm.weight', 'output.weight', 'tok_embeddings.weight']) +EXPECTED_LORA_KEYS = sorted(['layers.0.attention.wq.lora_A.weight', 'layers.0.attention.wq.lora_B.weight', 'layers.0.attention.wk.lora_A.weight', 'layers.0.attention.wk.lora_B.weight', 'layers.0.attention.wv.lora_A.weight', 'layers.0.attention.wv.lora_B.weight', 'layers.0.attention.wo.lora_A.weight', 'layers.0.attention.wo.lora_B.weight', 'layers.0.feed_forward.w1.lora_A.weight', 'layers.0.feed_forward.w1.lora_B.weight', 'layers.0.feed_forward.w2.lora_A.weight', 'layers.0.feed_forward.w2.lora_B.weight', 'layers.0.feed_forward.w3.lora_A.weight', 'layers.0.feed_forward.w3.lora_B.weight', 'layers.1.attention.wq.lora_A.weight', 'layers.1.attention.wq.lora_B.weight', 'layers.1.attention.wk.lora_A.weight', 'layers.1.attention.wk.lora_B.weight', 'layers.1.attention.wv.lora_A.weight', 'layers.1.attention.wv.lora_B.weight', 'layers.1.attention.wo.lora_A.weight', 'layers.1.attention.wo.lora_B.weight', 'layers.1.feed_forward.w1.lora_A.weight', 'layers.1.feed_forward.w1.lora_B.weight', 'layers.1.feed_forward.w2.lora_A.weight', 'layers.1.feed_forward.w2.lora_B.weight', 'layers.1.feed_forward.w3.lora_A.weight', 'layers.1.feed_forward.w3.lora_B.weight']) +# fmt: on + + +@pytest.mark.parametrize( + ("world_size", "save_only_lora", "enable_lora"), + [ + (1, False, False), + (2, False, False), + (1, False, True), + (2, False, True), + (1, True, True), + (2, True, True), # this is the most important test! - FSDP only LORA + ], +) +def test_states_retrieval(world_size, enable_lora, save_only_lora): + spawn_for_all_world_sizes( + _check_states_retrieval, + world_sizes=[world_size], + args=[enable_lora, save_only_lora], + deterministic=True, + ) + + +def _check_states_retrieval( + rank: int, + world_size: int, + filename: str, + filename_rpc: str, + enable_lora: bool, + save_only_lora: bool, +): + model_parallel = 1 + setup_mp_test_dist(rank, world_size, filename, model_parallel, seed=0) + + folder = Path(MODEL_PATH) + model = load_model( + folder=folder, + lora=LoraArgs(enable=enable_lora), + checkpoint=True, + param_dtype=torch.bfloat16, + ) + + # mock a train state that has done three steps + step = 3 + state = TrainState(max_steps=10, step=step) # 10 is just a dummy value here + + # mock run_dir as we won't save anything in this test + run_dir = Path("dir") + use_sf = True + + checkpointer = Checkpointer(model, state, run_dir=run_dir, num_ckpt_keep=None) + prefix = "lora" if enable_lora else "consolidated" + + assert checkpointer.dst_dir == Path( + f"dir/checkpoints/checkpoint_00000{step}/consolidated" + ), checkpointer.dst_dir + assert checkpointer.consolidated_path( + checkpointer.dst_dir, use_sf, save_only_lora=enable_lora + ) == Path( + f"dir/checkpoints/checkpoint_00000{step}/consolidated/{prefix}.safetensors" + ), checkpointer.consolidated_path( + checkpointer.dst_dir, use_sf, save_only_lora=enable_lora + ) + + # increase step by one + state.start_step() + + assert checkpointer.dst_dir == Path( + f"dir/checkpoints/checkpoint_00000{step + 1}/consolidated" + ), checkpointer.dst_dir + assert checkpointer.consolidated_path( + checkpointer.dst_dir, use_sf, save_only_lora=enable_lora + ) == Path( + f"dir/checkpoints/checkpoint_00000{step + 1}/consolidated/{prefix}.safetensors" + ), checkpointer.consolidated_path( + checkpointer.dst_dir, use_sf, save_only_lora=enable_lora + ) + + assert all("lora" in k for k in EXPECTED_LORA_KEYS), EXPECTED_LORA_KEYS + + for save_dtype in [torch.float16, torch.bfloat16, torch.float32]: + + save_dict = checkpointer.retrieve_save_states( + save_only_lora=save_only_lora, save_dtype=save_dtype + ) + + for k, v in save_dict.items(): + assert v.dtype == save_dtype, f"{k}: v.dtype" + + if save_only_lora: + assert sorted(save_dict.keys()) == EXPECTED_LORA_KEYS, save_dict.keys() + else: + assert sorted(save_dict.keys()) == EXPECTED_NON_LORA_KEYS, save_dict.keys() + + EXPECTED_NON_LORA_VALUES = 34909.7500 + + EXPECTED_LORA_VALUES = 984.4179840087891 + + values_sum = sum(v.abs().float().sum().item() for v in save_dict.values()) + + if save_only_lora: + assert is_float_equal( + values_sum, EXPECTED_LORA_VALUES, 5e-1 + ), f"{values_sum} for {save_dtype}" + else: + assert is_float_equal( + values_sum, EXPECTED_NON_LORA_VALUES, 1e-1 + ), f"{values_sum} for {save_dtype}" + + +@pytest.mark.parametrize("world_size", [1, 2]) +def test_lora_merge_equal(world_size): + spawn_for_all_world_sizes( + _check_lora_merge_equal, + world_sizes=[world_size], + deterministic=True, + ) + + +def _check_lora_merge_equal( + rank: int, world_size: int, filename: str, filename_rpc: str +): + model_parallel = 1 + enable_lora = True + setup_mp_test_dist(rank, world_size, filename, model_parallel, seed=0) + + world_size // model_parallel + + folder = Path(MODEL_PATH) + + step = 3 + state = TrainState(max_steps=10, step=step) # 10 is just a dummy value here + run_dir = Path("dir") + + non_lora_model = load_model( + folder=folder, + lora=LoraArgs(enable=False), + checkpoint=True, + param_dtype=torch.bfloat16, + ) + + non_lora_checkpointer = Checkpointer( + non_lora_model, state, run_dir=run_dir, num_ckpt_keep=None + ) + orig_model = non_lora_checkpointer.retrieve_save_states( + save_only_lora=False, save_dtype=torch.float32 + ) + + scaling = 2.0 + + model = load_model( + folder=folder, + lora=LoraArgs(enable=enable_lora, scaling=scaling), + checkpoint=True, + param_dtype=torch.bfloat16, + ) + + state_dict = model.state_dict() + state_dict = {k: v + 0.01 if "lora" in k else v for k, v in state_dict.items()} + model.load_state_dict(state_dict) + + # mock a train state that has done three steps + checkpointer = Checkpointer(model, state, run_dir=run_dir, num_ckpt_keep=None) + + for save_dtype in [torch.float16, torch.bfloat16, torch.float32]: + model_dict = { + k: torch.empty_like(v).copy_(v).to(save_dtype) + for k, v in orig_model.items() + } + merged_save_dict = checkpointer.retrieve_save_states( + save_only_lora=False, save_dtype=save_dtype + ) + + lora_save_dict = checkpointer.retrieve_save_states( + save_only_lora=True, save_dtype=save_dtype + ) + + merge_checkpoints( + model_dict, lora_save_dict, scaling=scaling, save_dtype=save_dtype + ) + + for k in model_dict.keys(): + torch.allclose( + model_dict[k].cpu(), merged_save_dict[k].cpu(), atol=1e-3, rtol=1e-3 + ) + + for k in model_dict.keys(): + # make sure that merged model differs from orig model + if "attention" in k or "feed_forward" in k: + not torch.allclose( + orig_model[k].to(save_dtype).cpu(), + merged_save_dict[k].cpu(), + atol=1e-3, + rtol=1e-3, + ) diff --git a/tests/test_data.py b/tests/test_data.py new file mode 100644 index 0000000000000000000000000000000000000000..e31b872bc3458afbff902ee61d14cac5c7461687 --- /dev/null +++ b/tests/test_data.py @@ -0,0 +1,729 @@ +import copy +import json +from pathlib import Path + +import numpy as np +import pytest +from mistral_common.protocol.instruct.messages import FinetuningAssistantMessage +from mistral_common.tokens.tokenizers.mistral import MistralTokenizer + +from finetune.data.args import DataArgs, InstructArgs +from finetune.data.data_loader import build_data_loader +from finetune.data.dataset import ( + DataFile, + SampleType, + get_dataset_iterator, + get_rng, + lazy_load_and_yield, + maybe_chunk_lines, + parse_data_sources, + preload_and_yield, +) +from finetune.data.tokenize import build_instruct_sample, encode + +from .test_utils import spawn_for_all_world_sizes + +# fmt: off +EXPECTED_X = [ + [ + # for pretrain + [ + # for DP=1 + [2051851, 1961139, 2000184, 2081307, 2341123, 1225437, 1739008, 724695, 570810, 632094] + ], + [ + # for DP=2 + [2020745, 1938377, 2244286, 2042079, 1824023], + [2103241, 2032118, 1868430, 1093072, 770996], + ] + ], + [ + # for instruct + [ + # for DP=1 + [1379941, 1438894, 965536, 1019713, 889921, 999322, 1647173, 941080, 1281597, 1584884] + ], + [ + # for DP=2 + [1379941, 1438894, 889899, 1005451, 876854], + [1034325, 999322, 982295, 941080, 725946], + ] + ] +] +EXPECTED_Y = [ + [ + # for pretrain + [ + # for DP=1 + [2081367, 1961098, 1970714, 2110856, 2334822, 1251057, 1745267, 699854, 571600, 660015] + ], + [ + # for DP=2 + [2021840, 1966833, 2223275, 2063077, 1824011], + [2132793, 2002569, 1870876, 1122569, 757126], + ] + ], + [ + # for instruct + [ + # for DP=1 + [1409448, 1430886, 937609, 1019339, 889921, 970976, 1660330, 942631, 1308399, 1583658] + ], + [ + # for DP=2 + [1409448, 1430886, 895531, 990091, 863522], + [1041462, 970976, 991091, 942631, 737311] + ] + ] +] +EXPECTED_MASKS = [ + [ + # for pretrain + [ + # for DP=1 + [0, 0, 0, 0, 0, 0, 0, 0, 0, 0] + ], + [ + # for DP=2 + [0, 0, 0, 0, 0], + [0, 0, 0, 0, 0], + ] + ], + [ + # for instruct + [ + # for DP=1 + [47, 0, 34, 0, 0, 82, 0, 0, 0, 0] + ], + [ + # for DP=2 + [47, 0, 4, 0, 0], + [19, 82, 0, 0, 23], + ] + ] +] + +EXPECTED_X_FUNC = [ + [ + # for DP=1 + [1005531, 1551735, 1261711, 1531024, 1280259, 1069883, 858107, 1021583, 1203265, 1242999], + ], + [ + # for DP=2 + [985281, 1217766, 1442139, 1533790, 1253607], + [1005531, 1551735, 1261711, 1531024, 1280259], + ] +] + +EXPECTED_Y_FUNC = [ + [ + # for DP=1 + [977126, 1580120, 1233326, 1559463, 1280241, 1042456, 879031, 994127, 1196263, 1270581], + ], + [ + # for DP=2 + [957934, 1218899, 1441783, 1533011, 1224541], + [977126, 1580120, 1233326, 1559463, 1280241], + ] +] + +EXPECTED_MASKS_FUNC = [ + [ + # for DP=1 + [91, 0, 0, 0, 0, 77, 0, 0, 53, 0], + ], + [ + # for DP=2 + [16, 47, 0, 86, 98], + [91, 0, 0, 0, 0], + ] +] +# fmt: on + + +class MockTokenizer: + def encode(self, content: str, *args, **kwargs) -> str: + return content + + +class MockInstructTokenizerBaseBase: + def __init__(self): + self.tokenizer = MockTokenizer() + + def encode_user_message(self, message, *args, **kwargs): + return message.content + + def encode_assistant_message(self, message, *args, **kwargs): + return message.content + + def start(self): + return [] + + +def stringify(samples): + lines = [] + for sample in samples: + string_list = sample.tokens + lines.append("".join(string_list)) + + return lines + + +@pytest.mark.parametrize( + ("world_size", "model_parallel", "is_instruct"), + [ + (1, 1, False), + (2, 1, False), + (2, 2, False), + (1, 1, True), + (2, 1, True), + (2, 2, True), + ], +) +def test_data_loader_dist(world_size, model_parallel, is_instruct): + spawn_for_all_world_sizes( + _check_data_loader_dist, + world_sizes=[world_size], + args=[model_parallel, is_instruct], + deterministic=True, + ) + + +def _check_data_loader_dist( + rank: int, + world_size: int, + filename: str, + filename_rpc: str, + model_parallel: int, + is_instruct: bool, +): + dp_world_size = world_size // model_parallel + dp_rank = rank // model_parallel + + seed = 0 + seq_len = 100 + batch_size = 1 + + instruct = InstructArgs(shuffle=False, dynamic_chunk_fn_call=False) + + if is_instruct: + # at the moment we have to pass some instuction finetuning + data_args = DataArgs( + data="", + instruct_data="tests/fixtures/sample_instruct.jsonl:.1,tests/fixtures/sample_instruct_2.jsonl:.1,tests/fixtures/sample_instruct_3.jsonl:.1", + instruct=instruct, + ) + else: + data_args = DataArgs( + data="tests/fixtures/sample_pretrain_1.jsonl:1.0,tests/fixtures/sample_pretrain_2.jsonl:1.0", + instruct_data="tests/fixtures/sample_instruct.jsonl:.01", + instruct=instruct, + ) + + instruct_tokenizer = MistralTokenizer.v3().instruct_tokenizer + + data_loader = build_data_loader( + instruct_tokenizer, + data_args, + batch_size, + seq_len, + seed=seed, + rank=dp_rank, + world_size=dp_world_size, + is_eval=False, + ) + + x_sums = [] + y_sums = [] + masks = [] + + num_samples = 10 // dp_world_size + + for _ in range(num_samples): + batch = next(data_loader) + x_sums.append(batch.x.sum()) + y_sums.append(batch.y.sum()) + mask_sum = batch.y_mask.sum() if batch.y_mask is not None else 0 + masks.append(mask_sum) + + expected_x_sums = EXPECTED_X[is_instruct][dp_world_size - 1][dp_rank] + expected_y_sums = EXPECTED_Y[is_instruct][dp_world_size - 1][dp_rank] + expected_masks = EXPECTED_MASKS[is_instruct][dp_world_size - 1][dp_rank] + + print(f"rank: {rank}, world_size: {world_size}, x: {x_sums}") + print(f"rank: {rank}, world_size: {world_size}, y: {y_sums}") + print(f"rank: {rank}, world_size: {world_size}, x shape: {masks}") + + assert x_sums == expected_x_sums, x_sums + assert y_sums == expected_y_sums, y_sums + assert masks == expected_masks, masks + + +@pytest.mark.parametrize("world_size", [1, 2]) +def test_data_loader_dist_fn_call(world_size): + spawn_for_all_world_sizes( + _check_data_loader_dist_fn_call, + world_sizes=[world_size], + deterministic=True, + ) + + +def _check_data_loader_dist_fn_call( + rank: int, + world_size: int, + filename: str, + filename_rpc: str, +): + dp_world_size = world_size + dp_rank = rank + + seed = 0 + seq_len = 100 + batch_size = 1 + + data_args = DataArgs( + data="", + instruct_data="tests/fixtures/sample_instruct_fn_call_short.jsonl:.3", + instruct=InstructArgs(shuffle=True, dynamic_chunk_fn_call=True), + ) + + instruct_tokenizer = MistralTokenizer.v3().instruct_tokenizer + + data_loader = build_data_loader( + instruct_tokenizer, + data_args, + batch_size, + seq_len, + seed=seed, + rank=dp_rank, + world_size=dp_world_size, + is_eval=False, + ) + + x_sums = [] + y_sums = [] + masks = [] + + num_samples = 10 // dp_world_size + + for _ in range(num_samples): + batch = next(data_loader) + x_sums.append(batch.x.sum()) + y_sums.append(batch.y.sum()) + mask_sum = batch.y_mask.sum() if batch.y_mask is not None else 0 + masks.append(mask_sum) + + expected_x_sums = EXPECTED_X_FUNC[dp_world_size - 1][dp_rank] + expected_y_sums = EXPECTED_Y_FUNC[dp_world_size - 1][dp_rank] + expected_masks = EXPECTED_MASKS_FUNC[dp_world_size - 1][dp_rank] + + assert x_sums == expected_x_sums, x_sums + assert y_sums == expected_y_sums, y_sums + assert masks == expected_masks, masks + + +def test_data_loader_equal_fsdp(): + spawn_for_all_world_sizes( + _check_data_loader_equal_fsdp, + world_sizes=[2], + deterministic=True, + ) + + +def _check_data_loader_equal_fsdp( + rank: int, + world_size: int, + filename: str, + filename_rpc: str, +): + model_parallel = 2 + world_size // model_parallel + rank // model_parallel + + seed = 0 + seq_len = 100 + batch_size = 1 + + instruct = InstructArgs(shuffle=False, dynamic_chunk_fn_call=False) + + data_args = DataArgs( + data="", + instruct_data="tests/fixtures/sample_instruct.jsonl:.1,tests/fixtures/sample_instruct_2.jsonl:.1,tests/fixtures/sample_instruct_3.jsonl:.1", + instruct=instruct, + ) + + instruct_tokenizer = MistralTokenizer.v3().instruct_tokenizer + + data_loader_0 = build_data_loader( + instruct_tokenizer, + data_args, + batch_size, + seq_len, + seed=seed, + rank=0, + world_size=world_size, + is_eval=False, + ) + + data_loader_1 = build_data_loader( + instruct_tokenizer, + data_args, + batch_size, + seq_len, + seed=seed, + rank=1, + world_size=world_size, + is_eval=False, + ) + + x_sums = [] + y_sums = [] + + num_samples = 10 // 2 # run 5 * 2 training steps + + for _ in range(num_samples): + batch = next(data_loader_0) + x_sums.append(batch.x.sum()) + y_sums.append(batch.y.sum()) + + batch = next(data_loader_1) + x_sums.append(batch.x.sum()) + y_sums.append(batch.y.sum()) + + # check that mp can match ddp for both ranks + expected_x_sums = [ + y for x in zip(EXPECTED_X[1][1][0], EXPECTED_X[1][1][1]) for y in x + ] + expected_y_sums = [ + y for x in zip(EXPECTED_Y[1][1][0], EXPECTED_Y[1][1][1]) for y in x + ] + + assert x_sums == expected_x_sums, x_sums + assert y_sums == expected_y_sums, y_sums + + +def test_dynamic_fn_call_chunk(): + jsonl_file = Path("tests/fixtures/sample_instruct_fn_call_short.jsonl") + + non_chunked_samples = [] + with jsonl_file.open() as file_handle: + for line in file_handle: + non_chunked_samples.append(build_instruct_sample(json.loads(line))) + + num_expected_chunks = 0 + for sample in non_chunked_samples: + if sample.only_last: + num_expected_chunks += ( + sum(isinstance(m, FinetuningAssistantMessage) for m in sample.messages) + - 1 + ) + + chunked_samples = [] + with jsonl_file.open() as file_handle: + lines = file_handle.readlines() + extra_lines = maybe_chunk_lines(lines) + + for line in extra_lines: + chunked_samples.append(build_instruct_sample(json.loads(line))) + + assert num_expected_chunks == len(chunked_samples) + + +def test_dynamic_fn_call_chunk_integration(): + jsonl_file = Path("tests/fixtures/sample_instruct_fn_call_multi.jsonl") + + multi_samples = [] + with jsonl_file.open() as file_handle: + for line in file_handle: + multi_samples.append(build_instruct_sample(json.loads(line))) + + jsonl_file = Path("tests/fixtures/sample_instruct_fn_call_single.jsonl") + + chunked_samples = [] + with jsonl_file.open() as file_handle: + for line in file_handle: + chunked_samples.append(build_instruct_sample(json.loads(line))) + + with jsonl_file.open() as file_handle: + lines = file_handle.readlines() + extra_lines = maybe_chunk_lines(lines) + + for line in extra_lines: + chunked_samples.append(build_instruct_sample(json.loads(line))) + + assert list(reversed(multi_samples)) == chunked_samples + + +def test_fn_call(): + batch_size = 1 + data_args = DataArgs( + data="", + instruct_data="", + eval_instruct_data="tests/fixtures/sample_instruct_fn_call.jsonl", + ) + instruct_tokenizer = MistralTokenizer.v3().instruct_tokenizer + + seq_len = 10000 + + data_loader = build_data_loader( + instruct_tokenizer, + data_args, + batch_size, + seq_len, + seed=None, + rank=0, + world_size=1, + is_eval=True, + ) + + all_loss_strings = [] + for batch in data_loader: + y_mask = ( + np.asarray(batch.y_mask, int) + if batch.y_mask is not None + else np.ones_like(batch.x) + ) + + start_index = end_index = 0 + for size in batch.sizes: + end_index += size + tokens = batch.y[start_index:end_index] + mask = y_mask[start_index:end_index] + + tokens_for_loss = [int(y) for i, y in enumerate(tokens) if mask[i] == 1] + start_index += size + + decoded = instruct_tokenizer.tokenizer.decode(tokens_for_loss) + if len(decoded) > 0: + all_loss_strings.append(decoded) + + # Verify that the loss is always only computed over the + expected_loss_strings = [] + with open(data_args.eval_instruct_data, "r") as f: + for line in f: + data = json.loads(line) + last_message = data["interactions"][-1] + if "content" in last_message: + expected_loss_strings.append(last_message["content"]) + elif "tool_calls" in last_message: + tool_calls = last_message["tool_calls"] + arguments = tool_calls[0]["function"]["arguments"] + string = [ + { + "name": call["function"]["name"], + "arguments": json.loads(arguments), + } + for call in tool_calls + ] + expected_loss_strings.append(json.dumps(string)) + + assert expected_loss_strings == all_loss_strings + + +def test_data_weighting(): + data_args = DataArgs( + data="", + instruct_data="", + eval_instruct_data="tests/fixtures/sample_instruct.jsonl", + ) + + instruct_tokenizer = MistralTokenizer.v3().instruct_tokenizer + + jsonl_file = Path(data_args.eval_instruct_data) + + with jsonl_file.open() as file_handle: + data = json.loads(next(file_handle)) + + token_sample = encode(data, instruct_tokenizer, SampleType.INSTRUCT) + + data_weight_0 = copy.deepcopy(data) + data_weight_0["interactions"][-1]["weight"] = 0 + + token_sample_weight_0 = encode( + data_weight_0, instruct_tokenizer, SampleType.INSTRUCT + ) + + data_weight_1 = copy.deepcopy(data) + data_weight_1["interactions"][-1]["weight"] = 1 + + token_sample_weight_1 = encode( + data_weight_1, instruct_tokenizer, SampleType.INSTRUCT + ) + + assert ( + token_sample.tokens + == token_sample_weight_0.tokens + == token_sample_weight_1.tokens + ) + assert token_sample.masks == token_sample_weight_1.masks + assert token_sample.masks != token_sample_weight_0.masks + assert not any(token_sample_weight_0.masks) + + +def test_eval_dataloader(): + batch_size = 1 + + data_args = DataArgs( + data="", + instruct_data="", + eval_instruct_data="tests/fixtures/sample_instruct.jsonl,tests/fixtures/sample_instruct_2.jsonl,tests/fixtures/sample_instruct_3.jsonl", + ) + + instruct_tokenizer = MistralTokenizer.v3().instruct_tokenizer + + # make sure that for every seq len the same data is seen + for world_size in [1, 2, 8]: + for seq_len in [10, 100, 1000, 10000]: + x_sums = [] + y_sums = [] + y_masks = [] + + data_loaders = [] + for rank in range(world_size): + data_loaders.append( + build_data_loader( + instruct_tokenizer, + data_args, + batch_size, + seq_len, + seed=None, + rank=rank, + world_size=world_size, + is_eval=True, + ) + ) + + for data_loader in data_loaders: + for batch in data_loader: + mask = ( + np.asarray(batch.y_mask, int) + if batch.y_mask is not None + else np.ones_like(batch.x) + ) + x_sums.append((batch.x * mask).sum()) + y_sums.append((batch.y * mask).sum()) + y_masks.append(mask.sum()) + + assert len(batch.x) == len(mask) == len(batch.y) == seq_len + + assert sum(x_sums) == 71404835 + assert sum(y_sums) == 71404795 + assert sum(y_masks) == 5538 + + +def test_shuffle_data(): + instruct_tokenizer = MockInstructTokenizerBaseBase() + + data_args = DataArgs(data="", instruct_data="", eval_instruct_data="") + + data_file = Path("tests/fixtures/sample_instruct_long_1.jsonl") + + dataset_iterator = get_dataset_iterator( + source=DataFile(path=data_file, sample_type=SampleType.INSTRUCT), + instruct_args=data_args.instruct, + instruct_tokenizer=instruct_tokenizer, + rank=0, + world_size=1, + is_finite=False, + seed=0, + shuffle_at_epoch=True, + ) + + with data_file.open() as f: + lines = f.readlines() + lines = [ + encode( + json.loads(line), + instruct_tokenizer=instruct_tokenizer, + as_type=SampleType.INSTRUCT, + ) + for line in lines + ] + prev_lines = stringify(lines) + + num_lines = len(prev_lines) + + samples = [] + # run 4 epochs + for i in range(4 * num_lines): + samples.append(next(dataset_iterator)) + + if (i + 1) % num_lines == 0: + # epoch finished! + # check that order is different but all lines have the same hash + lines = stringify(samples) + assert lines != prev_lines, "No shuffling - make sure dataset is shuffled!" + assert sorted(lines) == sorted( + prev_lines + ), "datasets need to match at every epoch" + + prev_lines = lines + samples = [] + + +@pytest.mark.parametrize("world_size", [1, 2]) +def test_shuffle_data_same_as_no_shuffle(world_size): + spawn_for_all_world_sizes( + _check_shuffle_data_same_as_no_shuffle, + world_sizes=[world_size], + deterministic=True, + ) + + +def _check_shuffle_data_same_as_no_shuffle( + rank: int, + world_size: int, + filename: str, + filename_rpc: str, +): + instruct_tokenizer = MockInstructTokenizerBaseBase() + + instruct = InstructArgs(shuffle=False, dynamic_chunk_fn_call=False) + + data_args = DataArgs( + data="tests/fixtures/sample_pretrain_1.jsonl:1.0,tests/fixtures/sample_pretrain_2.jsonl:1.0", + instruct_data="tests/fixtures/sample_instruct.jsonl:.1,tests/fixtures/sample_instruct_2.jsonl:.1,tests/fixtures/sample_instruct_3.jsonl:.1", + instruct=instruct, + ) + + sources, _ = parse_data_sources( + pretrain_data=data_args.data, instruct_data=data_args.instruct_data + ) + + seed = 0 + rng = get_rng(seed, rank) + + for source in sources: + jsonl_files = source.jsonl_files + chunk_dataset = source.sample_type == SampleType.INSTRUCT + + for jsonl_file in jsonl_files: + samples = [[], []] + for shuffle in [True, False]: + print(jsonl_file) + if shuffle: + iterator = preload_and_yield( + jsonl_file, + chunk_dataset=chunk_dataset, + rank=rank, + world_size=world_size, + rng=rng, + instruct_tokenizer=instruct_tokenizer, + sample_type=source.sample_type, + ) + else: + iterator = lazy_load_and_yield( + jsonl_file, + rank=rank, + world_size=world_size, + instruct_tokenizer=instruct_tokenizer, + sample_type=source.sample_type, + ) + + for tokens in iterator: + samples[shuffle].append(tokens) + + strings_0 = sorted(stringify(samples[0])) + strings_1 = sorted(stringify(samples[1])) + + assert strings_0 == strings_1 diff --git a/tests/test_mixed_precision.py b/tests/test_mixed_precision.py new file mode 100644 index 0000000000000000000000000000000000000000..c00c33577106cbaeaef5b3bcbf526d632d557aba --- /dev/null +++ b/tests/test_mixed_precision.py @@ -0,0 +1,136 @@ +from pathlib import Path + +import pytest +import torch + +from finetune.args import LoraArgs +from finetune.loss import compute_loss_with_mask +from finetune.mixed_precision import ( + downcast_mixed_precision, + prepare_mixed_precision, + upcast_mixed_precision, +) +from finetune.wrapped_model import load_model +from tests.test_utils import MODEL_PATH, get_dataloader, setup_mp_test_dist + +from .test_utils import spawn_for_all_world_sizes + + +@pytest.mark.parametrize( + ("world_size", "enable_lora"), [(1, False), (1, True), (2, False), (2, True)] +) +def test_mixed_precision(world_size, enable_lora): + spawn_for_all_world_sizes( + _check_mixed_precision, + world_sizes=[world_size], + args=[enable_lora], + deterministic=True, + ) + + +def _check_mixed_precision( + rank: int, world_size: int, filename: str, filename_rpc: str, enable_lora: bool +): + model_parallel = 1 + setup_mp_test_dist(rank, world_size, filename, model_parallel, seed=0) + seq_len = 100 + + folder = Path(MODEL_PATH) + # mixed precision + param_dtype = torch.bfloat16 + optim_dtype = torch.float32 + + model = load_model( + folder=folder, + lora=LoraArgs(enable=enable_lora), + checkpoint=True, + param_dtype=param_dtype, + ) + + optimizer = torch.optim.AdamW(model.parameters()) + + # initialize mixed precision training for TP + prepare_mixed_precision( + model.parameters(), param_dtype=param_dtype, optim_dtype=optim_dtype + ) + + data_loader = get_dataloader(seq_len=seq_len) + + # ensure every parameter that requires a grad has a _mp_param of optim_dtype precision + for param in model.parameters(): + assert param.dtype == param_dtype + if param.requires_grad: + assert param._mp_param.dtype == optim_dtype + assert ( + param._mp_param.tolist() == param.data.to(optim_dtype).tolist() + ), "mp param has to match param in optim dtype precision" + else: + assert not hasattr(param, "_mp_param") + + # test three train steps + for _ in range(3): + + optimizer.zero_grad() + + # micro-batching + for _ in range(2): + batch = next(data_loader) + + x = torch.from_numpy(batch.x).cuda(non_blocking=True) + y = torch.from_numpy(batch.y).cuda(non_blocking=True) + y_mask = ( + torch.from_numpy(batch.y_mask).cuda(non_blocking=True) + if batch.y_mask is not None + else None + ) + + output = model( + input_ids=x, + seqlens=batch.sizes, + ) + + mb_loss = compute_loss_with_mask(output, y, y_mask) + mb_loss.backward() + + upcast_mixed_precision(model.parameters(), optim_dtype=optim_dtype) + + # ensure all params are upcasted correctly and mp param equals param + param_sum = 0 + for param in model.parameters(): + if param.requires_grad: + assert param.dtype == optim_dtype, param.dtype + assert ( + param._mp_param.tolist() == param.data.tolist() + ), "mp param and param should point to the same data" + assert param.grad.dtype == optim_dtype + assert param._temp.dtype == param_dtype + param_sum += param.data.float().abs().sum() + else: + assert param.dtype == param_dtype + + optimizer.step() + + # ensure that after optimizer step params are still in optim dtype precision + new_param_sum = 0 + for param in model.parameters(): + if param.requires_grad: + assert param.dtype == optim_dtype + assert param._mp_param.dtype == optim_dtype + assert param.grad.dtype == optim_dtype + new_param_sum += param.data.float().abs().sum() + else: + assert param.dtype == param_dtype + + assert new_param_sum != param_sum, "Make sure parameters are updated" + + downcast_mixed_precision(model.parameters(), param_dtype=param_dtype) + + # ensure that before new forward pass params are downcasted to param dtype + for param in model.parameters(): + assert param.dtype == param_dtype + if param.requires_grad: + assert param._mp_param.dtype == optim_dtype + assert param.grad.dtype == param_dtype + assert ( + param._mp_param.to(param_dtype).tolist() == param.data.tolist() + ), "mp param has to match param in optim dtype precision" diff --git a/tests/test_model.py b/tests/test_model.py new file mode 100644 index 0000000000000000000000000000000000000000..ee6af5ba029ae0fbc21109af8e8aeaaa406270ab --- /dev/null +++ b/tests/test_model.py @@ -0,0 +1,550 @@ +import tempfile +from pathlib import Path +from typing import Dict + +import pytest +import torch + +from finetune.args import LoraArgs +from finetune.checkpointing import Checkpointer +from finetune.loss import compute_loss_with_mask +from finetune.mixed_precision import ( + downcast_mixed_precision, + prepare_mixed_precision, + upcast_mixed_precision, +) +from finetune.utils import TrainState +from finetune.wrapped_model import load_model +from model.transformer import ( + LoRALinear, +) +from tests.test_utils import ( + MODEL_PATH, + get_dataloader, + is_float_equal, + setup_mp_test_dist, +) + +from .test_utils import spawn_for_all_world_sizes + +torch.backends.cudnn.deterministic = True # use deterministic algorithms +torch.backends.cudnn.benchmark = False # disable cuDNN benchmark + + +@pytest.mark.parametrize( + ("world_size", "enable_lora", "dtype"), + [ + (1, False, torch.float32), + (1, True, torch.float32), + (2, False, torch.float32), + (2, True, torch.float32), + (1, False, torch.bfloat16), + (1, True, torch.bfloat16), + (2, False, torch.bfloat16), + (2, True, torch.bfloat16), + ], +) +def test_weights_loading(world_size, enable_lora, dtype): + spawn_for_all_world_sizes( + _check_weights_loading, + world_sizes=[world_size], + args=[enable_lora, dtype], + deterministic=True, + ) + + +def _check_weights_loading( + rank: int, + world_size: int, + filename: str, + filename_rpc: str, + enable_lora: bool, + dtype: torch.dtype, +): + model_parallel = 1 + setup_mp_test_dist(rank, world_size, filename, model_parallel, seed=0) + + folder = Path(MODEL_PATH) + model = load_model( + folder=folder, + lora=LoraArgs(enable=enable_lora), + checkpoint=True, + param_dtype=dtype, + ) + + # add hook so that LoRA weights are automatically merged: + def register_merge_lora_hook(m: torch.nn.Module): + def merge_lora( + m: torch.nn.Module, destination: Dict[str, torch.Tensor], prefix: str, *args + ): + weight = m.merge_weight() + destination[prefix + "weight"] = weight + + if isinstance(m, LoRALinear): + m._merge_lora_handle = m._register_state_dict_hook(merge_lora) + + model.apply(register_merge_lora_hook) + + if world_size > 1: + with model.summon_full_params(model, writeback=True): + states = { + k: v + for k, v in model.state_dict().items() + if "lora" not in k and "frozen" not in k + } + else: + states = { + k: v + for k, v in model.state_dict().items() + if "lora" not in k and "frozen" not in k + } + + EXP_PARAM_SUM = 308.9932 if dtype == torch.float32 else 308.0 + params = sum([v.sum() for v in states.values()]).item() + + # LoRA is equal to no LoRA as LoRA weights should be init to 0 + assert is_float_equal(params, EXP_PARAM_SUM), params + + if enable_lora: + lora_B_params = [ + v.float().abs().sum() for k, v in model.named_parameters() if "lora_B" in k + ] + + assert len(lora_B_params) > 0 + assert sum(lora_B_params) == 0, "Lora_B should always be zero init" + + lora_A_params = [ + v.float().abs().sum() for k, v in model.named_parameters() if "lora_A" in k + ] + + assert len(lora_A_params) > 0 + assert sum(lora_A_params) > 0, "Lora_A should init to non-zero values" + + +@pytest.mark.parametrize( + ("world_size", "enable_lora"), [(1, False), (1, True), (2, False), (2, True)] +) +def test_fsdp_logits_and_loss(world_size, enable_lora): + spawn_for_all_world_sizes( + _check_fsdp_logits_and_loss, + world_sizes=[world_size], + args=[enable_lora], + deterministic=True, + ) + + +def _check_fsdp_logits_and_loss( + rank: int, world_size: int, filename: str, filename_rpc: str, enable_lora: bool +): + model_parallel = 1 + setup_mp_test_dist(rank, world_size, filename, model_parallel, seed=0) + seq_len = 100 + + folder = Path(MODEL_PATH) + model = load_model( + folder=folder, + lora=LoraArgs(enable=enable_lora), + checkpoint=True, + param_dtype=torch.bfloat16, + ) + # By seting equal rank and world_size we can assure that both ranks see the same data and hence the average + data_loader = get_dataloader(seq_len=seq_len, rank=0, world_size=2) + + batch = next(data_loader) + + x = torch.from_numpy(batch.x).cuda(non_blocking=True) + y = torch.from_numpy(batch.y).cuda(non_blocking=True) + y_mask = torch.from_numpy(batch.y_mask).cuda(non_blocking=True) + + # forward / backward + output = model( + input_ids=x, + seqlens=batch.sizes, + ) + + # check logits + # logits should be the same for LoRA and non-LoRA + assert output.shape == (seq_len, model.args.vocab_size) + output_sum = output.abs().float().sum().item() + + EXP_OUTPUT_WORLD_1 = 162617.625 + + assert is_float_equal(output_sum, EXP_OUTPUT_WORLD_1, precision=1e1), output_sum + + # check loss is the same for all + # loss should be the same for LoRA and non-LoRA + mb_loss = compute_loss_with_mask(output, y, y_mask) + + EXPECTED_LOSS = 10.408413887023926 + + assert is_float_equal(mb_loss.item(), EXPECTED_LOSS), mb_loss.item() + + +@pytest.mark.parametrize( + ("world_size", "dtype"), + [(1, torch.bfloat16), (2, torch.bfloat16), (1, torch.float32), (2, torch.float32)], +) +def test_fsdp_grads_non_lora(world_size, dtype): + spawn_for_all_world_sizes( + _check_fsdp_grads_non_lora, + world_sizes=[world_size], + deterministic=True, + args=[dtype], + ) + + +def _check_fsdp_grads_non_lora( + rank: int, world_size: int, filename: str, filename_rpc: str, dtype: torch.dtype +): + model_parallel = 1 + setup_mp_test_dist(rank, world_size, filename, model_parallel, seed=0) + seq_len = 2048 + + folder = Path(MODEL_PATH) + model = load_model( + folder=folder, + lora=LoraArgs(enable=False), + checkpoint=True, + param_dtype=dtype, + ) + # same world_size to check for equality + data_loader = get_dataloader(seq_len=seq_len, rank=0, world_size=2) + + batch = next(data_loader) + + x = torch.from_numpy(batch.x).cuda(non_blocking=True) + y = torch.from_numpy(batch.y).cuda(non_blocking=True) + y_mask = torch.from_numpy(batch.y_mask).cuda(non_blocking=True) + + # forward / backward + output = model( + input_ids=x, + seqlens=batch.sizes, + ) + + mb_loss = compute_loss_with_mask(output, y, y_mask) + mb_loss.backward() + + num_grad_params = sum([p.grad.numel() for p in model.parameters()]) + + assert (4301120 // world_size) == num_grad_params, num_grad_params + + torch.distributed.barrier() + + sharded_flat_grads = sum( + [p.grad.float().abs().sum().item() for p in model.parameters()] + ) + + print(f"{rank}: {world_size}: {dtype} = {sharded_flat_grads}") + + EXP_GRAD_WORLD_2_RANK_0 = 95.45827150344849 + EXP_GRAD_WORLD_2_RANK_1 = 86.09188461303711 + EXP_GRAD_WORLD_1 = EXP_GRAD_WORLD_2_RANK_0 + EXP_GRAD_WORLD_2_RANK_1 + + if world_size == 1: + assert is_float_equal( + sharded_flat_grads, EXP_GRAD_WORLD_1, 2.0e-1 + ), sharded_flat_grads + elif world_size == 2 and rank == 0: + assert is_float_equal( + sharded_flat_grads, EXP_GRAD_WORLD_2_RANK_0, 2.0e-1 + ), sharded_flat_grads + elif world_size == 2 and rank == 1: + assert is_float_equal( + sharded_flat_grads, EXP_GRAD_WORLD_2_RANK_1, 2.0e-1 + ), sharded_flat_grads + + +@pytest.mark.parametrize( + ("world_size", "dtype"), + [(1, torch.bfloat16), (2, torch.bfloat16), (1, torch.float32), (2, torch.float32)], +) +def test_fsdp_grads_lora(world_size, dtype): + spawn_for_all_world_sizes( + _check_fsdp_grads_lora, + world_sizes=[world_size], + deterministic=True, + args=[dtype], + ) + + +def _check_fsdp_grads_lora( + rank: int, world_size: int, filename: str, filename_rpc: str, dtype: torch.dtype +): + model_parallel = 1 + setup_mp_test_dist(rank, world_size, filename, model_parallel, seed=0) + seq_len = 2048 + + folder = Path(MODEL_PATH) + model = load_model( + folder=folder, + lora=LoraArgs(enable=True), + checkpoint=True, + param_dtype=dtype, + ) + # same world_size to check for equality + data_loader = get_dataloader(seq_len=seq_len, rank=0, world_size=2) + + batch = next(data_loader) + + x = torch.from_numpy(batch.x).cuda(non_blocking=True) + y = torch.from_numpy(batch.y).cuda(non_blocking=True) + y_mask = torch.from_numpy(batch.y_mask).cuda(non_blocking=True) + + # forward / backward + output = model( + input_ids=x, + seqlens=batch.sizes, + ) + + mb_loss = compute_loss_with_mask(output, y, y_mask) + mb_loss.backward() + + num_grad_params = sum( + [p.grad.numel() for p in model.parameters() if p.grad is not None] + ) + + assert (40960 // world_size) == num_grad_params, num_grad_params + + torch.distributed.barrier() + + sharded_flat_grads = sum( + [ + p.grad.float().abs().sum().item() + for p in model.parameters() + if p.grad is not None + ] + ) + + print(f"{rank}: {world_size}: {dtype} = {sharded_flat_grads}") + + EXP_GRAD_WORLD_2_RANK_0 = 3.0742580661177635 + EXP_GRAD_WORLD_2_RANK_1 = 3.074301045779139 + EXP_GRAD_WORLD_1 = EXP_GRAD_WORLD_2_RANK_0 + EXP_GRAD_WORLD_2_RANK_1 + + if world_size == 1: + assert is_float_equal( + sharded_flat_grads, EXP_GRAD_WORLD_1, 2.0e-1 + ), sharded_flat_grads + elif world_size == 2 and rank == 0: + assert is_float_equal( + sharded_flat_grads, EXP_GRAD_WORLD_2_RANK_0, 2.0e-1 + ), sharded_flat_grads + elif world_size == 2 and rank == 1: + assert is_float_equal( + sharded_flat_grads, EXP_GRAD_WORLD_2_RANK_1, 2.0e-1 + ), sharded_flat_grads + + +@pytest.mark.parametrize( + ("world_size", "dtype"), + [(1, torch.bfloat16), (2, torch.bfloat16), (1, torch.float32), (2, torch.float32)], +) +def test_grad_update_lora(world_size, dtype): + spawn_for_all_world_sizes( + _check_grad_update_lora, + world_sizes=[world_size], + args=[dtype], + deterministic=True, + ) + + +def _check_grad_update_lora( + rank: int, world_size: int, filename: str, filename_rpc: str, dtype: torch.dtype +): + model_parallel = 1 + setup_mp_test_dist(rank, world_size, filename, model_parallel, seed=0) + seq_len = 1000 + + folder = Path(MODEL_PATH) + model = load_model( + folder=folder, + lora=LoraArgs(enable=True), + checkpoint=True, + param_dtype=dtype, + ) + optimizer = torch.optim.AdamW(model.parameters()) + + data_loader = get_dataloader(seq_len=seq_len) + + batch = next(data_loader) + + x = torch.from_numpy(batch.x).cuda(non_blocking=True) + y = torch.from_numpy(batch.y).cuda(non_blocking=True) + y_mask = ( + torch.from_numpy(batch.y_mask).cuda(non_blocking=True) + if batch.y_mask is not None + else None + ) + + # forward / backward + output = model( + input_ids=x, + seqlens=batch.sizes, + ) + + mb_loss = compute_loss_with_mask(output, y, y_mask) + mb_loss.backward() + + lora_weight_sum = 0 + non_lora_weight_sum = 0 + for name, param in model.named_parameters(): + if "lora" in name or "norm" in name: + assert param.grad is not None, name + lora_weight_sum += param.data.float().abs().sum() + else: + assert param.grad is None, name + non_lora_weight_sum += param.data.float().abs().sum() + + # update weights + optimizer.step() + + new_lora_weight_sum = 0 + new_non_lora_weight_sum = 0 + for name, param in model.named_parameters(): + if "lora" in name or "norm" in name: + assert param.grad is not None, name + new_lora_weight_sum += param.data.float().abs().sum() + else: + assert param.grad is None, name + new_non_lora_weight_sum += param.data.float().abs().sum() + + # make sure that LoRA weights changed, but non-LoRA weights stayed the same + assert not is_float_equal( + new_lora_weight_sum, lora_weight_sum, 1e-4 + ), f"New: {new_lora_weight_sum}, Old: {lora_weight_sum}" + assert is_float_equal( + new_non_lora_weight_sum, non_lora_weight_sum, 1e-4 + ), f"New: {new_non_lora_weight_sum}, Old: {non_lora_weight_sum}" + + +@pytest.mark.parametrize( + ("enable_lora", "param_dtype"), + [ + (False, torch.float32), + (True, torch.float32), + (False, torch.bfloat16), + (True, torch.bfloat16), + ], +) +def test_grads_fsdp_mp(enable_lora, param_dtype): + with tempfile.TemporaryDirectory() as tmpdirname: + for world_size in [1, 2]: + spawn_for_all_world_sizes( + _check_grads_fsdp_mp, + world_sizes=[world_size], + deterministic=True, + args=[tmpdirname, enable_lora, param_dtype], + ) + + w1_sd = torch.load(Path(tmpdirname) / Path("params_w1.pt"), map_location="cpu") + w2_sd = torch.load(Path(tmpdirname) / Path("params_w2.pt"), map_location="cpu") + + for k in w1_sd.keys(): + assert w1_sd[k].shape == w2_sd[k].shape, k + atol = 10 if param_dtype == torch.float32 else 100 + assert (w1_sd[k] - w2_sd[k]).sum().abs().item() < atol + + +def _check_grads_fsdp_mp( + rank: int, + world_size: int, + filename: str, + filename_rpc: str, + tmpdirname: str, + enable_lora: bool, + param_dtype: torch.dtype, +): + model_parallel = 1 + setup_mp_test_dist(rank, world_size, filename, model_parallel, seed=0) + seq_len = 4096 + + optim_dtype = torch.float32 + + folder = Path(MODEL_PATH) + model = load_model( + folder=folder, + lora=LoraArgs(enable=enable_lora), + checkpoint=True, + param_dtype=param_dtype, + ) + + # high learning rate to show differences + optimizer = torch.optim.AdamW(model.parameters(), lr=0.1) + + # mock a train state that has done three steps + steps = 4 + state = TrainState(max_steps=steps) + + # mock run_dir as we won't save anything in this test + run_dir = Path(tmpdirname) + + checkpointer = Checkpointer(model, state, run_dir=run_dir, num_ckpt_keep=None) + + # make sure the same data is seen + dataloaders = [ + get_dataloader(seq_len=seq_len, rank=rank + i, world_size=2) + for i in range(2 - world_size + 1) + ] + + prepare_mixed_precision( + model.parameters(), param_dtype=param_dtype, optim_dtype=optim_dtype + ) + + for _ in range(steps): + state.start_step() + optimizer.zero_grad() + + for data_loader in dataloaders: + torch.manual_seed(0) + batch = next(data_loader) + + x = torch.from_numpy(batch.x).cuda() + y = torch.from_numpy(batch.y).cuda() + y_mask = ( + torch.from_numpy(batch.y_mask).cuda(non_blocking=True) + if batch.y_mask is not None + else None + ) + + # forward / backward + output = model( + input_ids=x, + seqlens=batch.sizes, + ) + + mb_loss = compute_loss_with_mask(output, y, y_mask) + mb_loss.backward() + + assert model.params[0].dtype == param_dtype + + print(f"rank: {rank}, world_size: {world_size}, x: {x.abs().sum()}") + print(f"rank: {rank}, world_size: {world_size}, y: {y.abs().sum()}") + print(f"rank: {rank}, world_size: {world_size}, x shape: {x.shape}") + + if y_mask is not None: + print( + f"rank: {rank}, world_size: {world_size}, y_mask: {y_mask.abs().sum()}" + ) + print(f"rank: {rank}, world_size: {world_size}, loss: {mb_loss}") + + for p in model.parameters(): + if p.requires_grad: + assert p.grad is not None + p.grad.div_(len(dataloaders)) + + max_norm = 1.0 + model.clip_grad_norm_(max_norm=max_norm) + + upcast_mixed_precision(model.parameters(), optim_dtype=optim_dtype) + + optimizer.step() + + downcast_mixed_precision(model.parameters(), param_dtype=param_dtype) + + save_dict = checkpointer.retrieve_save_states( + save_only_lora=enable_lora, save_dtype=torch.float32 + ) + + path = "params_w1.pt" if world_size == 1 else "params_w2.pt" + torch.save(save_dict, Path(tmpdirname) / Path(path)) diff --git a/tests/test_train_loop.py b/tests/test_train_loop.py new file mode 100644 index 0000000000000000000000000000000000000000..5505b4f9d88a270b6807735e14c2aae8dfbf53b3 --- /dev/null +++ b/tests/test_train_loop.py @@ -0,0 +1,93 @@ +import os +import tempfile +from contextlib import ExitStack +from pathlib import Path + +import pytest +import safetensors +import torch + +from finetune.args import LoraArgs, OptimArgs, TrainArgs +from finetune.data.args import DataArgs, InstructArgs +from tests.test_utils import DATA_PATH, EVAL_DATA_PATH, MODEL_PATH, setup_mp_test_dist +from train import _train + +from .test_utils import spawn_for_all_world_sizes + + +def file_size_and_md5(file_path): + # Check if the file exists + if not os.path.isfile(file_path): + return "Error: File not found" + + # Get the size of the file + file_size = os.path.getsize(file_path) + + # Open the file in binary mode + state_dict = safetensors.torch.load_file(file_path) + md5_sum = sum(v.abs().sum().item() for v in state_dict.values()) + + return file_size, md5_sum + + +@pytest.mark.parametrize("enable_lora", [False, True]) +def test_integration(enable_lora): + torch.backends.cudnn.deterministic = True # use deterministic algorithms + torch.backends.cudnn.benchmark = False # disable cuDNN benchmark + + instruct = InstructArgs(shuffle=False, dynamic_chunk_fn_call=False) + + data_args = DataArgs( + data="", + instruct_data=DATA_PATH, + eval_instruct_data=EVAL_DATA_PATH, + instruct=instruct, + ) + + model_path = MODEL_PATH + optim_args = OptimArgs(lr=0.01, weight_decay=0.1, pct_start=0.0) + + with tempfile.TemporaryDirectory() as tmpdirname: + args = TrainArgs( + data=data_args, + model_id_or_path=model_path, + run_dir=tmpdirname, + seed=0, + optim=optim_args, + max_steps=4, + num_microbatches=1, + lora=LoraArgs(enable=enable_lora), + ckpt_only_lora=enable_lora, + checkpoint=True, + no_eval=False, + ) + spawn_for_all_world_sizes( + _run_dummy_train, + world_sizes=[2], + deterministic=True, + args=[args], + ) + + prefix = "lora" if enable_lora else "consolidated" + ckpt_path = Path(tmpdirname) / Path( + f"checkpoints/checkpoint_00000{args.max_steps}/consolidated/{prefix}.safetensors" + ) + assert ckpt_path.exists() + + file_size, hash = file_size_and_md5(ckpt_path) + + EXPECTED_FILE_SIZE = [8604200, 84760] + + EXPECTED_HASH = [50515.5, 1296.875] + + assert file_size == EXPECTED_FILE_SIZE[enable_lora], file_size + assert abs(hash - EXPECTED_HASH[enable_lora]) < 1e-2, hash + + +def _run_dummy_train( + rank: int, world_size: int, filename: str, filename_rpc: str, args: TrainArgs +): + setup_mp_test_dist(rank, world_size, filename, 1, seed=0) + + with ExitStack() as exit_stack: + _train(args, exit_stack) diff --git a/tests/test_utils.py b/tests/test_utils.py new file mode 100644 index 0000000000000000000000000000000000000000..b434757df1136642f2f63339e27b425f35722d89 --- /dev/null +++ b/tests/test_utils.py @@ -0,0 +1,227 @@ +import os +import tempfile +from datetime import timedelta +from typing import Any, Callable, Dict, List, Optional + +import torch +import torch.distributed as dist +from mistral_common.tokens.tokenizers.mistral import MistralTokenizer + +from finetune.data.args import DataArgs, InstructArgs +from finetune.data.data_loader import build_data_loader +from finetune.distributed import get_rank, get_world_size +from finetune.utils import set_random_seed + + +def is_float_equal(a, b, precision=5e-3): + return abs(a - b) < precision + + +MODEL_PATH = os.getenv("DUMMY_MODEL") +assert MODEL_PATH != "", "Provide a path to a dummy model" +DATA_PATH = "tests/fixtures/sample_instruct.jsonl:.1,tests/fixtures/sample_instruct_2.jsonl:.1,tests/fixtures/sample_instruct_3.jsonl:.1" +EVAL_DATA_PATH = "tests/fixtures/sample_instruct.jsonl,tests/fixtures/sample_instruct_2.jsonl,tests/fixtures/sample_instruct_3.jsonl" + + +# Model parallel group that the current rank belongs to. +_MODEL_PARALLEL_GROUP = None +# Data parallel group that the current rank belongs to. +_DATA_PARALLEL_GROUP = None +# Pipeline parallel group that the current rank belongs to. +_PIPELINE_PARALLEL_GROUP = None + +_PIPELINE_PARALLEL_RANKS = None + + +def rmf(filename: str) -> None: + """Remove a file like rm -f.""" + try: + os.remove(filename) + except FileNotFoundError: + pass + + +def test_runner( + rank: int, test_func: Callable, deterministic: bool = False, *args: List[Any], **kwargs: Dict[str, Any] +) -> None: + # At this point we're in a new process, torch options need to be set again + if deterministic: + torch.backends.cudnn.deterministic = True + torch.backends.cudnn.benchmark = False + torch.manual_seed(1357) + + test_func(rank, *args, **kwargs) + + +def spawn_for_all_world_sizes( + test_func: Callable, world_sizes: List[int] = [], args: Any = [], deterministic: bool = False +) -> None: + for world_size in world_sizes: + _, filename = tempfile.mkstemp() + _, filename_rpc = tempfile.mkstemp() + + try: + torch.multiprocessing.spawn( + test_runner, + args=(test_func, deterministic, world_size, filename, filename_rpc, *args), + nprocs=world_size, + join=True, + ) + finally: + rmf(filename) + rmf(filename_rpc) + +def initialize_model_parallel( + model_parallel_size_: int, + pipeline_length: int = 1, + *, + model_parallel_backend: Optional[str] = None, + pipeline_backend: Optional[str] = None, + ddp_backend: Optional[str] = None +) -> None: + """ + Initialize model data parallel groups. + + Arguments: + model_parallel_size: number of GPUs used to parallelize model. + + Let's say we have a total of 8 GPUs denoted by g0 ... g7 and we + use 2 GPUs to parallelize the model. The present function will + create 4 model parallel groups and 2 data parallel groups as: + 4 model parallel groups: + [g0, g1], [g2, g3], [g4, g5], [g6, g7] + 2 data parallel groups: + [g0, g2, g4, g6], [g1, g3, g5, g7] + Note that for efficiency, the caller should make sure adjacent ranks + are on the same DGX box. For example if we are using 2 DGX-1 boxes + with a total of 16 GPUs, rank 0 to 7 belong to the first box and + ranks 8 to 15 belong to the second box. + """ + # Get world size and rank. Ensure some consistencies. + assert torch.distributed.is_initialized() + world_size = torch.distributed.get_world_size() + model_parallel_size = int(min(model_parallel_size_, world_size)) + rank = torch.distributed.get_rank() + + data_parallel_size = int(world_size / (model_parallel_size * pipeline_length)) + + if torch.distributed.get_rank() == 0: + print("> initializing model parallel with size {}".format(model_parallel_size_)) + print("> initializing ddp with size {}".format(data_parallel_size)) + print("> initializing pipeline with size {}".format(pipeline_length)) + + groups = torch.LongTensor(range(world_size)).reshape(data_parallel_size, pipeline_length, model_parallel_size) + + found = torch.where(groups == rank) + assert all(len(x) == 1 for x in found) + found = [x[0] for x in found] + + # Build the data parallel groups. + global _DATA_PARALLEL_GROUP + assert _DATA_PARALLEL_GROUP is None, "data parallel group is already initialized" + for j in range(pipeline_length): + for k in range(model_parallel_size): + group = torch.distributed.new_group(groups[:, j, k].tolist(), backend=ddp_backend) + if j == found[1] and k == found[2]: + _DATA_PARALLEL_GROUP = group + + # Build the model parallel groups. + global _MODEL_PARALLEL_GROUP + assert _MODEL_PARALLEL_GROUP is None, "model parallel group is already initialized" + for i in range(data_parallel_size): + for j in range(pipeline_length): + group = torch.distributed.new_group(groups[i, j, :].tolist(), backend=model_parallel_backend) + if i == found[0] and j == found[1]: + _MODEL_PARALLEL_GROUP = group + + global _PIPELINE_PARALLEL_GROUP + assert _PIPELINE_PARALLEL_GROUP is None, "model parallel group is already initialized" + global _PIPELINE_PARALLEL_RANKS + assert _PIPELINE_PARALLEL_RANKS is None, "model parallel group is already initialized" + for i in range(data_parallel_size): + for k in range(model_parallel_size): + ranks = groups[i, :, k].tolist() + group = torch.distributed.new_group(ranks, backend=pipeline_backend) + if i == found[0] and k == found[2]: + _PIPELINE_PARALLEL_GROUP = group + _PIPELINE_PARALLEL_RANKS = ranks + + +def setup_mp_test_dist(rank, world_size, filename, model_parallel, seed=0): + dist_init_for_testing(rank, world_size, filename) + torch.cuda.set_device(rank) + + # Init NCCL + backend = "nccl" + initialize_model_parallel( + model_parallel, + model_parallel_backend=backend, + pipeline_backend=backend, + ddp_backend=backend, + ) + + set_random_seed(seed) + + if torch.cuda.is_available(): + torch.set_default_tensor_type(torch.cuda.FloatTensor) # type: ignore + + +def dist_init_for_testing( + rank: int, world_size: int, filename: str, filename_rpc: str = "", timeout: int = 30 +): + """ + Same than fairscale testing.dist_init but without rpc + + filename_rpc is here to keep same signature than fairscale init + """ + + os.environ["WORLD_SIZE"] = str(world_size) + os.environ["RANK"] = str(rank) + url = "file://" + filename + + backend = "nccl" if torch.cuda.is_available() else "gloo" + + if backend == "nccl" and torch.cuda.device_count() < world_size: + raise RuntimeError( + f"Requested world size {world_size} cannot be reached on this machine, not enough GPUs {torch.cuda.device_count()}" + ) + + dist.init_process_group( + backend=backend, + rank=rank, + world_size=world_size, + init_method=url, + timeout=timedelta(seconds=timeout), + ) + + +def get_dataloader( + seed: int = 0, + seq_len: int = 10000, + rank: Optional[int] = None, + world_size: Optional[int] = None, +): + batch_size = 1 + rank = rank if rank is not None else get_rank() + world_size = world_size if world_size is not None else get_world_size() + + instruct_tokenizer = MistralTokenizer.v3().instruct_tokenizer + + instruct = InstructArgs(shuffle=False, dynamic_chunk_fn_call=False) + + data_args = DataArgs( + data="", + instruct_data="tests/fixtures/sample_instruct.jsonl:.1,tests/fixtures/sample_instruct_2.jsonl:.1,tests/fixtures/sample_instruct_3.jsonl:.1", + instruct=instruct, + ) + data_loader = build_data_loader( + instruct_tokenizer, + data_args, + batch_size, + seq_len, + seed=seed, + rank=rank, + world_size=world_size, + is_eval=False, + ) + return data_loader diff --git a/train.py b/train.py new file mode 100644 index 0000000000000000000000000000000000000000..425b1804ffc206bd7761a7c37694e0fe5e23bdd3 --- /dev/null +++ b/train.py @@ -0,0 +1,329 @@ +import dataclasses +import logging +import os +import pprint +from contextlib import ExitStack +from pathlib import Path +from typing import TYPE_CHECKING + +import fire +import torch.cuda +import torch.distributed as dist +from mistral_common.tokens.tokenizers.mistral import MistralTokenizer +from torch.optim import AdamW, lr_scheduler + +from finetune.args import TrainArgs +from finetune.checkpointing import Checkpointer +from finetune.data.data_loader import build_data_loader +from finetune.distributed import ( + BACKEND, + avg_aggregate, + get_rank, + get_world_size, + is_torchrun, + set_device, +) +from finetune.eval import evaluate +from finetune.loss import compute_loss_with_mask +from finetune.mixed_precision import ( + downcast_mixed_precision, + prepare_mixed_precision, + upcast_mixed_precision, +) +from finetune.monitoring.metrics_logger import ( + MetricsLogger, + eval_log_msg, + get_eval_logs, + get_train_logs, + train_log_msg, +) +from finetune.monitoring.utils import set_logger +from finetune.utils import ( + TrainState, + logged_closing, + set_random_seed, +) +from finetune.wrapped_model import load_model + +if TYPE_CHECKING: + from mistral_common.tokens.tokenizers.sentencepiece import InstructTokenizerBase + +logger = logging.getLogger("train") + + +def main_logger_info(message: str) -> None: + if get_rank() == 0: + logger.info(message) + #wandb.log({"info": message}) + + +def train(config: str): + args: TrainArgs = TrainArgs.load(config, drop_extra_fields=False) + print(f"args: {args}") + set_logger(logging.INFO) + + #if get_rank() == 0: + # wandb.init(project="CHEMISTral7b-ft",entity = "oops") + # wandb.config.update(dataclasses.asdict(args)) + + + with ExitStack() as exit_stack: + _train(args, exit_stack) + logger.info("Closed everything!") + + +def _train( + args: TrainArgs, + exit_stack: ExitStack, +): + # 1. Initial setup and checks + set_random_seed(args.seed) + + # Init NCCL + if "LOCAL_RANK" in os.environ: + set_device() + logger.info("Going to init comms...") + + dist.init_process_group(backend=BACKEND) + else: + logger.error( + "PyTorch environment is not correctly initialized. This message should only be displayed when testing." + ) + + # 2. Init run dir + main_logger_info(f"Run dir: {args.run_dir}") + run_dir = Path(args.run_dir) + + if is_torchrun(): + if run_dir.exists(): + raise RuntimeError( + f"Run dir {run_dir} already exists. Make sure to either rename `run_dir` or remove {run_dir}." + ) + + dist.barrier() + run_dir.mkdir(exist_ok=True, parents=True) + + args_path = run_dir / "args.yaml" + if not args_path.exists(): + args.save(args_path) + + main_logger_info(f"TrainArgs: {pprint.pformat(dataclasses.asdict(args))}") + + # 3. Get loggers + metrics_logger: MetricsLogger = MetricsLogger( + run_dir, + tag="train", + is_master=get_rank() == 0, + wandb_args=args.wandb, + mlflow_args=args.mlflow, + config=dataclasses.asdict(args), + ) + exit_stack.enter_context(logged_closing(metrics_logger, "metrics_logger")) + + eval_logger: MetricsLogger = MetricsLogger( + run_dir, + tag="eval", + is_master=get_rank() == 0, + wandb_args=args.wandb, + mlflow_args=args.mlflow, + config=dataclasses.asdict(args), + ) + exit_stack.enter_context(logged_closing(eval_logger, "eval_logger")) + + # 5. Potentially download model + if Path(args.model_id_or_path).is_dir(): + model_folder = Path(args.model_id_or_path) + else: + raise ValueError( + "Invalid folder path. Please set `args.initial_model` to a valid folder path." + ) + + # 6. Load function calling instruct tokenizer + instruct_tokenizer: InstructTokenizerBase = MistralTokenizer.v3().instruct_tokenizer # type: ignore + + # 7. Load data loaders + data_loader = build_data_loader( + instruct_tokenizer=instruct_tokenizer, + args=args.data, + seq_len=args.seq_len, + batch_size=args.batch_size, + seed=args.seed, + rank=get_rank(), # DDP rank + world_size=get_world_size(), # DDP world_size + is_eval=False, + ) + + if not args.no_eval: + assert ( + args.data.eval_instruct_data != "" + ), "Either set `no_eval` to True or provide evaluation samples under `data.eval_instruct_data`" + + eval_data_loader = build_data_loader( + instruct_tokenizer=instruct_tokenizer, + args=args.data, + seq_len=args.seq_len, + batch_size=args.batch_size, + seed=None, + rank=get_rank(), # DDP rank + world_size=get_world_size(), # DDP world_size + is_eval=True, + ) + # pre-load all eval tokens + eval_batches = list(eval_data_loader) + + # 8. Load model + # Define mixed precision + param_dtype = torch.bfloat16 + optim_dtype = torch.float32 + + assert args.lora is not None, "`args.lora` should be set to a valid value." + + model = load_model( + folder=model_folder, + lora=args.lora, + checkpoint=args.checkpoint, + param_dtype=param_dtype, + ) + + # 9. Load optimizer + optimizer = AdamW( + model.parameters(), + lr=args.optim.lr, + betas=(0.9, 0.95), + eps=1e-08, + weight_decay=args.optim.weight_decay, + ) + + scheduler = lr_scheduler.OneCycleLR( + optimizer, + max_lr=args.optim.lr, + total_steps=args.max_steps, + pct_start=args.optim.pct_start, + ) + + state = TrainState(args.max_steps) + + # 10. Initialize checkpointer + checkpointer = Checkpointer( + model=model, + state=state, + run_dir=run_dir, + optimizer=optimizer, + num_ckpt_keep=args.num_ckpt_keep, + ) + # 11. Prepare mixed precision + prepare_mixed_precision( + model.parameters(), param_dtype=param_dtype, optim_dtype=optim_dtype + ) + + # 12. train! + model.train() + torch.cuda.empty_cache() + + while state.step < args.max_steps: + state.start_step() + is_last_step = state.step == args.max_steps + + optimizer.zero_grad() + + loss = torch.tensor([0.0], device="cuda") + n_batch_tokens: int = 0 + + for i in range(args.num_microbatches): + # batch + batch = next(data_loader) + + x = torch.from_numpy(batch.x).cuda(non_blocking=True) + y = torch.from_numpy(batch.y).cuda(non_blocking=True) + y_mask = ( + torch.from_numpy(batch.y_mask).cuda(non_blocking=True) + if batch.y_mask is not None + else None + ) + + # forward / backward + output = model( + input_ids=x, + seqlens=batch.sizes, + ) + mb_loss = compute_loss_with_mask(output, y, y_mask) + + mb_loss.backward() + + loss += mb_loss.detach() + n_batch_tokens += x.numel() + + if i < args.num_microbatches - 1: + # synchronize CUDA to re-run backward + assert args.num_microbatches > 1 # should not happen + torch.cuda.synchronize() + + if args.num_microbatches > 1: + loss /= args.num_microbatches + for p in model.parameters(): + if p.requires_grad: + assert p.grad is not None + p.grad.div_(args.num_microbatches) + + # upcast params for optimizer update + upcast_mixed_precision(model.parameters(), optim_dtype=optim_dtype) + + # clip gra d norm + model.clip_grad_norm_(max_norm=args.max_norm) + + # optimizer step + optimizer.step() + + # downcast params for forward & backward + downcast_mixed_precision(model.parameters(), param_dtype=param_dtype) + + last_lr = scheduler.get_last_lr()[0] + scheduler.step() + + # Host sync + loss_item = loss.item() + avg_loss = avg_aggregate(loss_item) + + if not args.no_eval and ( + (args.eval_freq > 0 and state.step % args.eval_freq == 0) or is_last_step + ): + # write perplexity to state + evaluate(model, eval_batches, state) + + eval_logs = get_eval_logs( + state.step, avg_loss, state.this_eval_perplexity, state.this_eval_loss + ) + + main_logger_info(eval_log_msg(eval_logs)) + eval_logger.log(eval_logs, step=state.step) + + # Timing + state.end_step(n_batch_tokens) + + if state.step % args.log_freq == 0: + train_logs = get_train_logs( + state, + avg_loss, + last_lr, + torch.cuda.max_memory_allocated(), + torch.cuda.memory_allocated(), + args, + ) + main_logger_info(train_log_msg(state, logs=train_logs, loss=avg_loss)) + metrics_logger.log(train_logs, step=state.step) + + if not args.no_ckpt and ( + (args.ckpt_freq > 0 and state.step % args.ckpt_freq == 0) or is_last_step + ): + checkpointer.save_checkpoint( + save_only_lora=args.ckpt_only_lora, + dtype=param_dtype, + instruct_tokenizer=instruct_tokenizer, + ) + + main_logger_info("done!") + + +if __name__ == "__main__": + """See README.md for usage.""" + fire.Fire(train) diff --git a/tutorials/mistral_finetune_7b.ipynb b/tutorials/mistral_finetune_7b.ipynb new file mode 100644 index 0000000000000000000000000000000000000000..4426cd39c6a218e35c5e035b55bdcae37db7dafe --- /dev/null +++ b/tutorials/mistral_finetune_7b.ipynb @@ -0,0 +1,3244 @@ +{ + "nbformat": 4, + "nbformat_minor": 0, + "metadata": { + "colab": { + "provenance": [], + "machine_shape": "hm", + "gpuType": "A100" + }, + "kernelspec": { + "name": "python3", + "display_name": "Python 3" + }, + "language_info": { + "name": "python" + }, + "accelerator": "GPU", + "widgets": { + "application/vnd.jupyter.widget-state+json": { + "c06bbba05e10462d993f3e7e6f932cf1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_6f734c35284341d891a44694ddc55b2c", + "IPY_MODEL_193be53200ab436a967f1ea4807053e2", + "IPY_MODEL_85a2415f14284237875b349b4c414e21" + ], + "layout": "IPY_MODEL_3ab931b2fcc0493ca71923ebc37127c7" + } + }, + "6f734c35284341d891a44694ddc55b2c": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_f49472d0536f4011be17902f9e827807", + "placeholder": "​", + "style": "IPY_MODEL_2f341cb76f254d0da913faec6a82f762", + "value": "Fetching 3 files: 100%" + } + }, + "193be53200ab436a967f1ea4807053e2": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_24ebf383723f4de494f9808b41222751", + "max": 3, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_0c17aa90672046c9bd2f293b1a998b46", + "value": 3 + } + }, + "85a2415f14284237875b349b4c414e21": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_af89033247b34da2a5cded73b0beade2", + "placeholder": "​", + "style": "IPY_MODEL_0ea5f5e6ab26484ab22dcf5576f796d1", + "value": " 3/3 [01:49<00:00, 109.92s/it]" + } + }, + "3ab931b2fcc0493ca71923ebc37127c7": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "f49472d0536f4011be17902f9e827807": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2f341cb76f254d0da913faec6a82f762": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "24ebf383723f4de494f9808b41222751": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0c17aa90672046c9bd2f293b1a998b46": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "af89033247b34da2a5cded73b0beade2": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "0ea5f5e6ab26484ab22dcf5576f796d1": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "946ce9afeddb4da5a36e81e5ada9d957": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_95782b84af1c4014ae04c9e6c9131cbe", + "IPY_MODEL_2332101edec848219c3b0c6026c2a722", + "IPY_MODEL_a2638b3f10a24de99bb940dcd150ab53" + ], + "layout": "IPY_MODEL_1c78955b41ba4845931a250f16b753b5" + } + }, + "95782b84af1c4014ae04c9e6c9131cbe": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_148a8c3e4fad4cefa16a478a9758fdc5", + "placeholder": "​", + "style": "IPY_MODEL_92ef027f2cc940b5b09521328de550b0", + "value": "tokenizer.model.v3: 100%" + } + }, + "2332101edec848219c3b0c6026c2a722": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1a3d2764c7fc41dcb97489e84c28093e", + "max": 587404, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_c7b6155f0f844c67b3a2b805570fd6f9", + "value": 587404 + } + }, + "a2638b3f10a24de99bb940dcd150ab53": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_1eec374aa3414838a9b41e5db1fefd50", + "placeholder": "​", + "style": "IPY_MODEL_6fc8cf7aa81c4043878ac854b289dbe3", + "value": " 587k/587k [00:00<00:00, 5.39MB/s]" + } + }, + "1c78955b41ba4845931a250f16b753b5": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "148a8c3e4fad4cefa16a478a9758fdc5": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "92ef027f2cc940b5b09521328de550b0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1a3d2764c7fc41dcb97489e84c28093e": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "c7b6155f0f844c67b3a2b805570fd6f9": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "1eec374aa3414838a9b41e5db1fefd50": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "6fc8cf7aa81c4043878ac854b289dbe3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "b1aab1a3b5914048962a6d7d63401425": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_10fe81122e6442f28608766d90749790", + "IPY_MODEL_f7e72f0a87bc421b82a59ae9ad33a4cb", + "IPY_MODEL_2188b8f9491b4d3e8861e40e7c4f6a46" + ], + "layout": "IPY_MODEL_b3bf1880a5844f8c89096ced830fc954" + } + }, + "10fe81122e6442f28608766d90749790": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_7e0495ffdeb74675847e5e4c2104cc34", + "placeholder": "​", + "style": "IPY_MODEL_3e0e828a21f24944b68a66eafb52f62b", + "value": "params.json: 100%" + } + }, + "f7e72f0a87bc421b82a59ae9ad33a4cb": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_ee07a8e2427c4fc9bd09b27ad11e968a", + "max": 202, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_d35818e4f9454d26aa475826e08ea4f0", + "value": 202 + } + }, + "2188b8f9491b4d3e8861e40e7c4f6a46": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_e3f7c4fea8494af2a473cf61adccf270", + "placeholder": "​", + "style": "IPY_MODEL_7e18402efdb34d708b7917964ac791de", + "value": " 202/202 [00:00<00:00, 12.7kB/s]" + } + }, + "b3bf1880a5844f8c89096ced830fc954": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7e0495ffdeb74675847e5e4c2104cc34": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "3e0e828a21f24944b68a66eafb52f62b": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "ee07a8e2427c4fc9bd09b27ad11e968a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "d35818e4f9454d26aa475826e08ea4f0": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "e3f7c4fea8494af2a473cf61adccf270": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "7e18402efdb34d708b7917964ac791de": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "1442445cdf89487784d4a39919fec6bf": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HBoxModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HBoxModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HBoxView", + "box_style": "", + "children": [ + "IPY_MODEL_2ff8ebe8d132411585a05b852362c406", + "IPY_MODEL_ef719bb991714d91a365226c5a2ca9df", + "IPY_MODEL_1727f9b019e9477282d010e96b7dd4c3" + ], + "layout": "IPY_MODEL_f82b841d7e5b45229119bd3195e5b12f" + } + }, + "2ff8ebe8d132411585a05b852362c406": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_feb470b16b4249daaa19c1344d036f0a", + "placeholder": "​", + "style": "IPY_MODEL_2cc30eef6d7b46d283fcfd0e7abca6ea", + "value": "consolidated.safetensors: 100%" + } + }, + "ef719bb991714d91a365226c5a2ca9df": { + "model_module": "@jupyter-widgets/controls", + "model_name": "FloatProgressModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "FloatProgressModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "ProgressView", + "bar_style": "success", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_83b554bec0fd40dd9bd9e4601f2f98a3", + "max": 14496078512, + "min": 0, + "orientation": "horizontal", + "style": "IPY_MODEL_1c19998de61c4e2dad6647fdc4ca4358", + "value": 14496078512 + } + }, + "1727f9b019e9477282d010e96b7dd4c3": { + "model_module": "@jupyter-widgets/controls", + "model_name": "HTMLModel", + "model_module_version": "1.5.0", + "state": { + "_dom_classes": [], + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "HTMLModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/controls", + "_view_module_version": "1.5.0", + "_view_name": "HTMLView", + "description": "", + "description_tooltip": null, + "layout": "IPY_MODEL_25df0dd9481a4e0ba21d2f4f4ffdba2e", + "placeholder": "​", + "style": "IPY_MODEL_cbf620ae5196446c84528feaed64ae6a", + "value": " 14.5G/14.5G [01:49<00:00, 87.0MB/s]" + } + }, + "f82b841d7e5b45229119bd3195e5b12f": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "feb470b16b4249daaa19c1344d036f0a": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "2cc30eef6d7b46d283fcfd0e7abca6ea": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + }, + "83b554bec0fd40dd9bd9e4601f2f98a3": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "1c19998de61c4e2dad6647fdc4ca4358": { + "model_module": "@jupyter-widgets/controls", + "model_name": "ProgressStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "ProgressStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "bar_color": null, + "description_width": "" + } + }, + "25df0dd9481a4e0ba21d2f4f4ffdba2e": { + "model_module": "@jupyter-widgets/base", + "model_name": "LayoutModel", + "model_module_version": "1.2.0", + "state": { + "_model_module": "@jupyter-widgets/base", + "_model_module_version": "1.2.0", + "_model_name": "LayoutModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "LayoutView", + "align_content": null, + "align_items": null, + "align_self": null, + "border": null, + "bottom": null, + "display": null, + "flex": null, + "flex_flow": null, + "grid_area": null, + "grid_auto_columns": null, + "grid_auto_flow": null, + "grid_auto_rows": null, + "grid_column": null, + "grid_gap": null, + "grid_row": null, + "grid_template_areas": null, + "grid_template_columns": null, + "grid_template_rows": null, + "height": null, + "justify_content": null, + "justify_items": null, + "left": null, + "margin": null, + "max_height": null, + "max_width": null, + "min_height": null, + "min_width": null, + "object_fit": null, + "object_position": null, + "order": null, + "overflow": null, + "overflow_x": null, + "overflow_y": null, + "padding": null, + "right": null, + "top": null, + "visibility": null, + "width": null + } + }, + "cbf620ae5196446c84528feaed64ae6a": { + "model_module": "@jupyter-widgets/controls", + "model_name": "DescriptionStyleModel", + "model_module_version": "1.5.0", + "state": { + "_model_module": "@jupyter-widgets/controls", + "_model_module_version": "1.5.0", + "_model_name": "DescriptionStyleModel", + "_view_count": null, + "_view_module": "@jupyter-widgets/base", + "_view_module_version": "1.2.0", + "_view_name": "StyleView", + "description_width": "" + } + } + } + } + }, + "cells": [ + { + "cell_type": "markdown", + "source": [ + "# Getting starting fine-tuning Mistral 7B\n", + "\n", + "This notebook shows you a simple example of how to LoRA finetune Mistral 7B. You can can run this notebook in Google Colab with Pro + account with A100 and 40GB RAM.\n", + "\n", + "\n", + " \"Open\n", + "\n", + "\n", + "\n", + "Check out `mistral-finetune` Github repo to learn more: https://github.com/mistralai/mistral-finetune/" + ], + "metadata": { + "id": "RyuOCYM92LJb" + } + }, + { + "cell_type": "markdown", + "source": [ + "## Installation\n", + "\n", + "Clone the `mistral-finetune` repo:\n" + ], + "metadata": { + "id": "yxr8mv-17GfB" + } + }, + { + "cell_type": "code", + "source": [ + "%cd /content/\n", + "!git clone https://github.com/mistralai/mistral-finetune.git" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "TIj3IlIeVDIb", + "outputId": "6ffd6946-26a2-4e3d-e6db-3336cc2c7444" + }, + "execution_count": 3, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "/content\n", + "Cloning into 'mistral-finetune'...\n", + "remote: Enumerating objects: 62, done.\u001b[K\n", + "remote: Counting objects: 100% (62/62), done.\u001b[K\n", + "remote: Compressing objects: 100% (55/55), done.\u001b[K\n", + "remote: Total 62 (delta 6), reused 59 (delta 4), pack-reused 0\u001b[K\n", + "Receiving objects: 100% (62/62), 90.16 KiB | 3.00 MiB/s, done.\n", + "Resolving deltas: 100% (6/6), done.\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "Install all required dependencies:" + ], + "metadata": { + "id": "mQPd_pGT7WiY" + } + }, + { + "cell_type": "code", + "source": [ + "!pip install -r /content/mistral-finetune/requirements.txt" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "KuTOGipl7BS7", + "outputId": "0d332b99-54b1-431b-eb41-4b929087040c" + }, + "execution_count": 4, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Requirement already satisfied: fire in /usr/local/lib/python3.10/dist-packages (from -r /content/mistral-finetune/requirements.txt (line 1)) (0.6.0)\n", + "Requirement already satisfied: simple-parsing in /usr/local/lib/python3.10/dist-packages (from -r /content/mistral-finetune/requirements.txt (line 2)) (0.1.5)\n", + "Requirement already satisfied: pyyaml in /usr/local/lib/python3.10/dist-packages (from -r /content/mistral-finetune/requirements.txt (line 3)) (6.0.1)\n", + "Requirement already satisfied: mistral-common>=1.1.0 in /usr/local/lib/python3.10/dist-packages (from -r /content/mistral-finetune/requirements.txt (line 4)) (1.1.0)\n", + "Requirement already satisfied: safetensors in /usr/local/lib/python3.10/dist-packages (from -r /content/mistral-finetune/requirements.txt (line 5)) (0.4.3)\n", + "Requirement already satisfied: tensorboard in /usr/local/lib/python3.10/dist-packages (from -r /content/mistral-finetune/requirements.txt (line 6)) (2.15.2)\n", + "Requirement already satisfied: tqdm in /usr/local/lib/python3.10/dist-packages (from -r /content/mistral-finetune/requirements.txt (line 7)) (4.66.4)\n", + "Requirement already satisfied: torch==2.2 in /usr/local/lib/python3.10/dist-packages (from -r /content/mistral-finetune/requirements.txt (line 9)) (2.2.0)\n", + "Requirement already satisfied: triton==2.2 in /usr/local/lib/python3.10/dist-packages (from -r /content/mistral-finetune/requirements.txt (line 10)) (2.2.0)\n", + "Requirement already satisfied: xformers==0.0.24 in /usr/local/lib/python3.10/dist-packages (from -r /content/mistral-finetune/requirements.txt (line 11)) (0.0.24)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (3.14.0)\n", + "Requirement already satisfied: typing-extensions>=4.8.0 in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (4.11.0)\n", + "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (1.12)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (3.3)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (3.1.4)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (2023.6.0)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (12.1.105)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (12.1.105)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (12.1.105)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==8.9.2.26 in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (8.9.2.26)\n", + "Requirement already satisfied: nvidia-cublas-cu12==12.1.3.1 in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (12.1.3.1)\n", + "Requirement already satisfied: nvidia-cufft-cu12==11.0.2.54 in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (11.0.2.54)\n", + "Requirement already satisfied: nvidia-curand-cu12==10.3.2.106 in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (10.3.2.106)\n", + "Requirement already satisfied: nvidia-cusolver-cu12==11.4.5.107 in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (11.4.5.107)\n", + "Requirement already satisfied: nvidia-cusparse-cu12==12.1.0.106 in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (12.1.0.106)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.19.3 in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (2.19.3)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (12.1.105)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from xformers==0.0.24->-r /content/mistral-finetune/requirements.txt (line 11)) (1.25.2)\n", + "Requirement already satisfied: nvidia-nvjitlink-cu12 in /usr/local/lib/python3.10/dist-packages (from nvidia-cusolver-cu12==11.4.5.107->torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (12.5.40)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.10/dist-packages (from fire->-r /content/mistral-finetune/requirements.txt (line 1)) (1.16.0)\n", + "Requirement already satisfied: termcolor in /usr/local/lib/python3.10/dist-packages (from fire->-r /content/mistral-finetune/requirements.txt (line 1)) (2.4.0)\n", + "Requirement already satisfied: docstring-parser~=0.15 in /usr/local/lib/python3.10/dist-packages (from simple-parsing->-r /content/mistral-finetune/requirements.txt (line 2)) (0.16)\n", + "Requirement already satisfied: jsonschema==4.21.1 in /usr/local/lib/python3.10/dist-packages (from mistral-common>=1.1.0->-r /content/mistral-finetune/requirements.txt (line 4)) (4.21.1)\n", + "Requirement already satisfied: pydantic==2.6.1 in /usr/local/lib/python3.10/dist-packages (from mistral-common>=1.1.0->-r /content/mistral-finetune/requirements.txt (line 4)) (2.6.1)\n", + "Requirement already satisfied: sentencepiece==0.1.99 in /usr/local/lib/python3.10/dist-packages (from mistral-common>=1.1.0->-r /content/mistral-finetune/requirements.txt (line 4)) (0.1.99)\n", + "Requirement already satisfied: attrs>=22.2.0 in /usr/local/lib/python3.10/dist-packages (from jsonschema==4.21.1->mistral-common>=1.1.0->-r /content/mistral-finetune/requirements.txt (line 4)) (23.2.0)\n", + "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /usr/local/lib/python3.10/dist-packages (from jsonschema==4.21.1->mistral-common>=1.1.0->-r /content/mistral-finetune/requirements.txt (line 4)) (2023.12.1)\n", + "Requirement already satisfied: referencing>=0.28.4 in /usr/local/lib/python3.10/dist-packages (from jsonschema==4.21.1->mistral-common>=1.1.0->-r /content/mistral-finetune/requirements.txt (line 4)) (0.35.1)\n", + "Requirement already satisfied: rpds-py>=0.7.1 in /usr/local/lib/python3.10/dist-packages (from jsonschema==4.21.1->mistral-common>=1.1.0->-r /content/mistral-finetune/requirements.txt (line 4)) (0.18.1)\n", + "Requirement already satisfied: annotated-types>=0.4.0 in /usr/local/lib/python3.10/dist-packages (from pydantic==2.6.1->mistral-common>=1.1.0->-r /content/mistral-finetune/requirements.txt (line 4)) (0.7.0)\n", + "Requirement already satisfied: pydantic-core==2.16.2 in /usr/local/lib/python3.10/dist-packages (from pydantic==2.6.1->mistral-common>=1.1.0->-r /content/mistral-finetune/requirements.txt (line 4)) (2.16.2)\n", + "Requirement already satisfied: absl-py>=0.4 in /usr/local/lib/python3.10/dist-packages (from tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (1.4.0)\n", + "Requirement already satisfied: grpcio>=1.48.2 in /usr/local/lib/python3.10/dist-packages (from tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (1.64.0)\n", + "Requirement already satisfied: google-auth<3,>=1.6.3 in /usr/local/lib/python3.10/dist-packages (from tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (2.27.0)\n", + "Requirement already satisfied: google-auth-oauthlib<2,>=0.5 in /usr/local/lib/python3.10/dist-packages (from tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (1.2.0)\n", + "Requirement already satisfied: markdown>=2.6.8 in /usr/local/lib/python3.10/dist-packages (from tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (3.6)\n", + "Requirement already satisfied: protobuf!=4.24.0,>=3.19.6 in /usr/local/lib/python3.10/dist-packages (from tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (3.20.3)\n", + "Requirement already satisfied: requests<3,>=2.21.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (2.31.0)\n", + "Requirement already satisfied: setuptools>=41.0.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (67.7.2)\n", + "Requirement already satisfied: tensorboard-data-server<0.8.0,>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (0.7.2)\n", + "Requirement already satisfied: werkzeug>=1.0.1 in /usr/local/lib/python3.10/dist-packages (from tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (3.0.3)\n", + "Requirement already satisfied: cachetools<6.0,>=2.0.0 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (5.3.3)\n", + "Requirement already satisfied: pyasn1-modules>=0.2.1 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (0.4.0)\n", + "Requirement already satisfied: rsa<5,>=3.1.4 in /usr/local/lib/python3.10/dist-packages (from google-auth<3,>=1.6.3->tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (4.9)\n", + "Requirement already satisfied: requests-oauthlib>=0.7.0 in /usr/local/lib/python3.10/dist-packages (from google-auth-oauthlib<2,>=0.5->tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (1.3.1)\n", + "Requirement already satisfied: charset-normalizer<4,>=2 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (3.3.2)\n", + "Requirement already satisfied: idna<4,>=2.5 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (3.7)\n", + "Requirement already satisfied: urllib3<3,>=1.21.1 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (2.0.7)\n", + "Requirement already satisfied: certifi>=2017.4.17 in /usr/local/lib/python3.10/dist-packages (from requests<3,>=2.21.0->tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (2024.2.2)\n", + "Requirement already satisfied: MarkupSafe>=2.1.1 in /usr/local/lib/python3.10/dist-packages (from werkzeug>=1.0.1->tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (2.1.5)\n", + "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch==2.2->-r /content/mistral-finetune/requirements.txt (line 9)) (1.3.0)\n", + "Requirement already satisfied: pyasn1<0.7.0,>=0.4.6 in /usr/local/lib/python3.10/dist-packages (from pyasn1-modules>=0.2.1->google-auth<3,>=1.6.3->tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (0.6.0)\n", + "Requirement already satisfied: oauthlib>=3.0.0 in /usr/local/lib/python3.10/dist-packages (from requests-oauthlib>=0.7.0->google-auth-oauthlib<2,>=0.5->tensorboard->-r /content/mistral-finetune/requirements.txt (line 6)) (3.2.2)\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Model download" + ], + "metadata": { + "id": "LgdIAi257jLo" + } + }, + { + "cell_type": "code", + "source": [ + "!wget https://models.mistralcdn.com/mistral-7b-v0-3/mistral-7B-v0.3.tar" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/" + }, + "id": "cdl_R5baUyha", + "outputId": "8ddcc9d2-5088-47a8-b5f7-d73c89063246" + }, + "execution_count": 5, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "--2024-05-24 18:50:25-- https://models.mistralcdn.com/mistral-7b-v0-3/mistral-7B-v0.3.tar\n", + "Resolving models.mistralcdn.com (models.mistralcdn.com)... 104.26.6.117, 104.26.7.117, 172.67.70.68, ...\n", + "Connecting to models.mistralcdn.com (models.mistralcdn.com)|104.26.6.117|:443... connected.\n", + "HTTP request sent, awaiting response... 200 OK\n", + "Length: 14496675840 (14G) [application/x-tar]\n", + "Saving to: ‘mistral-7B-v0.3.tar’\n", + "\n", + "mistral-7B-v0.3.tar 100%[===================>] 13.50G 40.5MB/s in 6m 3s \n", + "\n", + "2024-05-24 18:56:29 (38.1 MB/s) - ‘mistral-7B-v0.3.tar’ saved [14496675840/14496675840]\n", + "\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "!DIR=/content/mistral_models && mkdir -p $DIR && tar -xf mistral-7B-v0.3.tar -C $DIR" + ], + "metadata": { + "id": "IgJWR-fReilz" + }, + "execution_count": 7, + "outputs": [] + }, + { + "cell_type": "code", + "source": [ + "# Alternatively, you can download the model from Hugging Face\n", + "\n", + "# !pip install huggingface_hub\n", + "# from huggingface_hub import snapshot_download\n", + "# from pathlib import Path\n", + "\n", + "# mistral_models_path = Path.home().joinpath('mistral_models', '7B-v0.3')\n", + "# mistral_models_path.mkdir(parents=True, exist_ok=True)\n", + "\n", + "# snapshot_download(repo_id=\"mistralai/Mistral-7B-v0.3\", allow_patterns=[\"params.json\", \"consolidated.safetensors\", \"tokenizer.model.v3\"], local_dir=mistral_models_path)\n", + "\n", + "#! cp -r /root/mistral_models/7B-v0.3 /content/mistral_models\n", + "#! rm -r /root/mistral_models/7B-v0.3" + ], + "metadata": { + "colab": { + "base_uri": "https://localhost:8080/", + "height": 163, + "referenced_widgets": [ + "c06bbba05e10462d993f3e7e6f932cf1", + "6f734c35284341d891a44694ddc55b2c", + "193be53200ab436a967f1ea4807053e2", + "85a2415f14284237875b349b4c414e21", + "3ab931b2fcc0493ca71923ebc37127c7", + "f49472d0536f4011be17902f9e827807", + "2f341cb76f254d0da913faec6a82f762", + "24ebf383723f4de494f9808b41222751", + "0c17aa90672046c9bd2f293b1a998b46", + "af89033247b34da2a5cded73b0beade2", + "0ea5f5e6ab26484ab22dcf5576f796d1", + "946ce9afeddb4da5a36e81e5ada9d957", + "95782b84af1c4014ae04c9e6c9131cbe", + "2332101edec848219c3b0c6026c2a722", + "a2638b3f10a24de99bb940dcd150ab53", + "1c78955b41ba4845931a250f16b753b5", + "148a8c3e4fad4cefa16a478a9758fdc5", + "92ef027f2cc940b5b09521328de550b0", + "1a3d2764c7fc41dcb97489e84c28093e", + "c7b6155f0f844c67b3a2b805570fd6f9", + "1eec374aa3414838a9b41e5db1fefd50", + "6fc8cf7aa81c4043878ac854b289dbe3", + "b1aab1a3b5914048962a6d7d63401425", + "10fe81122e6442f28608766d90749790", + "f7e72f0a87bc421b82a59ae9ad33a4cb", + "2188b8f9491b4d3e8861e40e7c4f6a46", + "b3bf1880a5844f8c89096ced830fc954", + "7e0495ffdeb74675847e5e4c2104cc34", + "3e0e828a21f24944b68a66eafb52f62b", + "ee07a8e2427c4fc9bd09b27ad11e968a", + "d35818e4f9454d26aa475826e08ea4f0", + "e3f7c4fea8494af2a473cf61adccf270", + "7e18402efdb34d708b7917964ac791de", + "1442445cdf89487784d4a39919fec6bf", + "2ff8ebe8d132411585a05b852362c406", + "ef719bb991714d91a365226c5a2ca9df", + "1727f9b019e9477282d010e96b7dd4c3", + "f82b841d7e5b45229119bd3195e5b12f", + "feb470b16b4249daaa19c1344d036f0a", + "2cc30eef6d7b46d283fcfd0e7abca6ea", + "83b554bec0fd40dd9bd9e4601f2f98a3", + "1c19998de61c4e2dad6647fdc4ca4358", + "25df0dd9481a4e0ba21d2f4f4ffdba2e", + "cbf620ae5196446c84528feaed64ae6a" + ] + }, + "id": "qgjAADBFHB0S", + "outputId": "6dd98910-36fd-4dc1-c5b8-77bb4c104e05" + }, + "execution_count": null, + "outputs": [ + { + "output_type": "display_data", + "data": { + "text/plain": [ + "Fetching 3 files: 0%| | 0/3 [00:002024-05-24 22:05:01\n", + "2024-05-24 19:00:41 (UTC) - 0:02:30 - train - INFO - step: 000002 - done (%): 2.0 - loss: 0.905 - lr: 1.8e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3624.4 - avg_words_per_second: 1008.4 - ETA: >2024-05-24 20:46:50\n", + "2024-05-24 19:00:59 (UTC) - 0:02:47 - train - INFO - step: 000003 - done (%): 3.0 - loss: 0.912 - lr: 5.2e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3706.1 - avg_words_per_second: 1331.5 - ETA: >2024-05-24 20:20:33\n", + "2024-05-24 19:01:17 (UTC) - 0:03:05 - train - INFO - step: 000004 - done (%): 4.0 - loss: 0.884 - lr: 8.6e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3591.8 - avg_words_per_second: 1580.0 - ETA: >2024-05-24 20:07:39\n", + "2024-05-24 19:01:35 (UTC) - 0:03:24 - train - INFO - step: 000005 - done (%): 5.0 - loss: 0.835 - lr: 1.0e-04 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3567.3 - avg_words_per_second: 1778.2 - ETA: >2024-05-24 19:59:57\n", + "2024-05-24 19:01:53 (UTC) - 0:03:42 - train - INFO - step: 000006 - done (%): 6.0 - loss: 0.858 - lr: 1.0e-04 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3710.8 - avg_words_per_second: 1947.2 - ETA: >2024-05-24 19:54:37\n", + "2024-05-24 19:02:11 (UTC) - 0:04:00 - train - INFO - step: 000007 - done (%): 7.0 - loss: 0.868 - lr: 1.0e-04 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3606.2 - avg_words_per_second: 2084.1 - ETA: >2024-05-24 19:50:55\n", + "2024-05-24 19:02:29 (UTC) - 0:04:18 - train - INFO - step: 000008 - done (%): 8.0 - loss: 0.868 - lr: 1.0e-04 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3622.3 - avg_words_per_second: 2201.0 - ETA: >2024-05-24 19:48:09\n", + "2024-05-24 19:02:47 (UTC) - 0:04:36 - train - INFO - step: 000009 - done (%): 9.0 - loss: 0.804 - lr: 1.0e-04 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3690.9 - avg_words_per_second: 2304.3 - ETA: >2024-05-24 19:45:55\n", + "2024-05-24 19:03:05 (UTC) - 0:04:54 - train - INFO - step: 000010 - done (%): 10.0 - loss: 0.898 - lr: 9.9e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3584.2 - avg_words_per_second: 2389.7 - ETA: >2024-05-24 19:44:13\n", + "2024-05-24 19:03:23 (UTC) - 0:05:12 - train - INFO - step: 000011 - done (%): 11.0 - loss: 0.744 - lr: 9.9e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3695.7 - avg_words_per_second: 2469.0 - ETA: >2024-05-24 19:42:45\n", + "2024-05-24 19:03:41 (UTC) - 0:05:30 - train - INFO - step: 000012 - done (%): 12.0 - loss: 0.837 - lr: 9.9e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3575.5 - avg_words_per_second: 2534.3 - ETA: >2024-05-24 19:41:37\n", + "2024-05-24 19:04:00 (UTC) - 0:05:48 - train - INFO - step: 000013 - done (%): 13.0 - loss: 0.846 - lr: 9.8e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3561.0 - avg_words_per_second: 2591.8 - ETA: >2024-05-24 19:40:40\n", + "2024-05-24 19:04:17 (UTC) - 0:06:06 - train - INFO - step: 000014 - done (%): 14.0 - loss: 0.854 - lr: 9.8e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3694.8 - avg_words_per_second: 2648.3 - ETA: >2024-05-24 19:39:46\n", + "2024-05-24 19:04:36 (UTC) - 0:06:24 - train - INFO - step: 000015 - done (%): 15.0 - loss: 0.911 - lr: 9.7e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3579.8 - avg_words_per_second: 2695.0 - ETA: >2024-05-24 19:39:03\n", + "2024-05-24 19:04:54 (UTC) - 0:06:42 - train - INFO - step: 000016 - done (%): 16.0 - loss: 0.815 - lr: 9.7e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3686.7 - avg_words_per_second: 2741.1 - ETA: >2024-05-24 19:38:22\n", + "2024-05-24 19:05:12 (UTC) - 0:07:00 - train - INFO - step: 000017 - done (%): 17.0 - loss: 0.821 - lr: 9.6e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3605.0 - avg_words_per_second: 2780.3 - ETA: >2024-05-24 19:37:48\n", + "2024-05-24 19:05:30 (UTC) - 0:07:19 - train - INFO - step: 000018 - done (%): 18.0 - loss: 0.842 - lr: 9.5e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3601.2 - avg_words_per_second: 2816.0 - ETA: >2024-05-24 19:37:18\n", + "2024-05-24 19:05:48 (UTC) - 0:07:36 - train - INFO - step: 000019 - done (%): 19.0 - loss: 0.802 - lr: 9.5e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3700.0 - avg_words_per_second: 2851.8 - ETA: >2024-05-24 19:36:49\n", + "2024-05-24 19:06:06 (UTC) - 0:07:54 - train - INFO - step: 000020 - done (%): 20.0 - loss: 0.867 - lr: 9.4e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3599.4 - avg_words_per_second: 2881.8 - ETA: >2024-05-24 19:36:25\n", + "2024-05-24 19:06:24 (UTC) - 0:08:13 - train - INFO - step: 000021 - done (%): 21.0 - loss: 0.826 - lr: 9.3e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3602.7 - avg_words_per_second: 2909.5 - ETA: >2024-05-24 19:36:03\n", + "2024-05-24 19:06:42 (UTC) - 0:08:30 - train - INFO - step: 000022 - done (%): 22.0 - loss: 0.809 - lr: 9.2e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3696.9 - avg_words_per_second: 2937.9 - ETA: >2024-05-24 19:35:42\n", + "2024-05-24 19:07:00 (UTC) - 0:08:49 - train - INFO - step: 000023 - done (%): 23.0 - loss: 0.837 - lr: 9.1e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3608.7 - avg_words_per_second: 2961.9 - ETA: >2024-05-24 19:35:24\n", + "2024-05-24 19:07:18 (UTC) - 0:09:06 - train - INFO - step: 000024 - done (%): 24.0 - loss: 0.851 - lr: 9.0e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3690.6 - avg_words_per_second: 2986.4 - ETA: >2024-05-24 19:35:05\n", + "2024-05-24 19:07:36 (UTC) - 0:09:24 - train - INFO - step: 000025 - done (%): 25.0 - loss: 0.856 - lr: 8.9e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3596.4 - avg_words_per_second: 3006.8 - ETA: >2024-05-24 19:34:51\n", + "2024-05-24 19:07:54 (UTC) - 0:09:43 - train - INFO - step: 000026 - done (%): 26.0 - loss: 0.781 - lr: 8.8e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3576.7 - avg_words_per_second: 3025.4 - ETA: >2024-05-24 19:34:37\n", + "2024-05-24 19:08:12 (UTC) - 0:10:01 - train - INFO - step: 000027 - done (%): 27.0 - loss: 0.845 - lr: 8.7e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3695.0 - avg_words_per_second: 3045.8 - ETA: >2024-05-24 19:34:23\n", + "2024-05-24 19:08:30 (UTC) - 0:10:19 - train - INFO - step: 000028 - done (%): 28.0 - loss: 0.831 - lr: 8.6e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3603.0 - avg_words_per_second: 3062.7 - ETA: >2024-05-24 19:34:11\n", + "2024-05-24 19:08:48 (UTC) - 0:10:37 - train - INFO - step: 000029 - done (%): 29.0 - loss: 0.806 - lr: 8.5e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3612.2 - avg_words_per_second: 3078.9 - ETA: >2024-05-24 19:34:00\n", + "2024-05-24 19:09:06 (UTC) - 0:10:55 - train - INFO - step: 000030 - done (%): 30.0 - loss: 0.898 - lr: 8.4e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3697.6 - avg_words_per_second: 3096.2 - ETA: >2024-05-24 19:33:48\n", + "2024-05-24 19:09:24 (UTC) - 0:11:13 - train - INFO - step: 000031 - done (%): 31.0 - loss: 0.817 - lr: 8.3e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3588.0 - avg_words_per_second: 3109.9 - ETA: >2024-05-24 19:33:38\n", + "2024-05-24 19:09:42 (UTC) - 0:11:31 - train - INFO - step: 000032 - done (%): 32.0 - loss: 0.825 - lr: 8.1e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3687.5 - avg_words_per_second: 3125.2 - ETA: >2024-05-24 19:33:28\n", + "2024-05-24 19:10:00 (UTC) - 0:11:49 - train - INFO - step: 000033 - done (%): 33.0 - loss: 0.845 - lr: 8.0e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3593.7 - avg_words_per_second: 3137.6 - ETA: >2024-05-24 19:33:20\n", + "2024-05-24 19:10:19 (UTC) - 0:12:07 - train - INFO - step: 000034 - done (%): 34.0 - loss: 0.808 - lr: 7.9e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3558.8 - avg_words_per_second: 3148.6 - ETA: >2024-05-24 19:33:12\n", + "2024-05-24 19:10:36 (UTC) - 0:12:25 - train - INFO - step: 000035 - done (%): 35.0 - loss: 0.853 - lr: 7.7e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3694.1 - avg_words_per_second: 3161.9 - ETA: >2024-05-24 19:33:04\n", + "2024-05-24 19:10:55 (UTC) - 0:12:43 - train - INFO - step: 000036 - done (%): 36.0 - loss: 0.813 - lr: 7.6e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3585.6 - avg_words_per_second: 3172.3 - ETA: >2024-05-24 19:32:57\n", + "2024-05-24 19:11:12 (UTC) - 0:13:01 - train - INFO - step: 000037 - done (%): 37.0 - loss: 0.801 - lr: 7.5e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3694.8 - avg_words_per_second: 3184.5 - ETA: >2024-05-24 19:32:49\n", + "2024-05-24 19:11:31 (UTC) - 0:13:19 - train - INFO - step: 000038 - done (%): 38.0 - loss: 0.744 - lr: 7.3e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3595.3 - avg_words_per_second: 3194.1 - ETA: >2024-05-24 19:32:43\n", + "2024-05-24 19:11:49 (UTC) - 0:13:37 - train - INFO - step: 000039 - done (%): 39.0 - loss: 0.816 - lr: 7.2e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3607.8 - avg_words_per_second: 3203.5 - ETA: >2024-05-24 19:32:37\n", + "2024-05-24 19:12:07 (UTC) - 0:13:55 - train - INFO - step: 000040 - done (%): 40.0 - loss: 0.786 - lr: 7.0e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3691.9 - avg_words_per_second: 3214.1 - ETA: >2024-05-24 19:32:30\n", + "2024-05-24 19:12:25 (UTC) - 0:14:13 - train - INFO - step: 000041 - done (%): 41.0 - loss: 0.804 - lr: 6.9e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3600.7 - avg_words_per_second: 3222.6 - ETA: >2024-05-24 19:32:25\n", + "2024-05-24 19:12:43 (UTC) - 0:14:32 - train - INFO - step: 000042 - done (%): 42.0 - loss: 0.845 - lr: 6.7e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3616.1 - avg_words_per_second: 3230.9 - ETA: >2024-05-24 19:32:19\n", + "2024-05-24 19:13:01 (UTC) - 0:14:49 - train - INFO - step: 000043 - done (%): 43.0 - loss: 0.864 - lr: 6.5e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3688.4 - avg_words_per_second: 3240.3 - ETA: >2024-05-24 19:32:14\n", + "2024-05-24 19:13:19 (UTC) - 0:15:07 - train - INFO - step: 000044 - done (%): 44.0 - loss: 0.862 - lr: 6.4e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3616.8 - avg_words_per_second: 3248.0 - ETA: >2024-05-24 19:32:09\n", + "2024-05-24 19:13:37 (UTC) - 0:15:25 - train - INFO - step: 000045 - done (%): 45.0 - loss: 0.862 - lr: 6.2e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3690.6 - avg_words_per_second: 3256.7 - ETA: >2024-05-24 19:32:03\n", + "2024-05-24 19:13:55 (UTC) - 0:15:43 - train - INFO - step: 000046 - done (%): 46.0 - loss: 0.829 - lr: 6.1e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3601.5 - avg_words_per_second: 3263.5 - ETA: >2024-05-24 19:31:59\n", + "2024-05-24 19:14:13 (UTC) - 0:16:02 - train - INFO - step: 000047 - done (%): 47.0 - loss: 0.812 - lr: 5.9e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3590.5 - avg_words_per_second: 3269.8 - ETA: >2024-05-24 19:31:55\n", + "2024-05-24 19:14:31 (UTC) - 0:16:19 - train - INFO - step: 000048 - done (%): 48.0 - loss: 0.818 - lr: 5.7e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3704.5 - avg_words_per_second: 3277.8 - ETA: >2024-05-24 19:31:50\n", + "2024-05-24 19:14:49 (UTC) - 0:16:38 - train - INFO - step: 000049 - done (%): 49.0 - loss: 0.817 - lr: 5.6e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3608.4 - avg_words_per_second: 3283.9 - ETA: >2024-05-24 19:31:47\n", + "2024-05-24 19:15:07 (UTC) - 0:16:56 - train - INFO - step: 000050 - done (%): 50.0 - loss: 0.888 - lr: 5.4e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3619.2 - avg_words_per_second: 3290.0 - ETA: >2024-05-24 19:31:43\n", + "2024-05-24 19:15:25 (UTC) - 0:17:13 - train - INFO - step: 000051 - done (%): 51.0 - loss: 0.777 - lr: 5.2e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3690.4 - avg_words_per_second: 3297.0 - ETA: >2024-05-24 19:31:39\n", + "2024-05-24 19:15:43 (UTC) - 0:17:32 - train - INFO - step: 000052 - done (%): 52.0 - loss: 0.804 - lr: 5.1e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3589.4 - avg_words_per_second: 3302.2 - ETA: >2024-05-24 19:31:36\n", + "2024-05-24 19:16:01 (UTC) - 0:17:49 - train - INFO - step: 000053 - done (%): 53.0 - loss: 0.800 - lr: 4.9e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3692.1 - avg_words_per_second: 3308.8 - ETA: >2024-05-24 19:31:32\n", + "2024-05-24 19:16:19 (UTC) - 0:18:08 - train - INFO - step: 000054 - done (%): 54.0 - loss: 0.804 - lr: 4.8e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3588.5 - avg_words_per_second: 3313.6 - ETA: >2024-05-24 19:31:29\n", + "2024-05-24 19:16:37 (UTC) - 0:18:26 - train - INFO - step: 000055 - done (%): 55.0 - loss: 0.854 - lr: 4.6e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3571.2 - avg_words_per_second: 3317.9 - ETA: >2024-05-24 19:31:26\n", + "2024-05-24 19:16:55 (UTC) - 0:18:44 - train - INFO - step: 000056 - done (%): 56.0 - loss: 0.819 - lr: 4.4e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3696.4 - avg_words_per_second: 3324.0 - ETA: >2024-05-24 19:31:23\n", + "2024-05-24 19:17:13 (UTC) - 0:19:02 - train - INFO - step: 000057 - done (%): 57.0 - loss: 0.844 - lr: 4.3e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3606.8 - avg_words_per_second: 3328.6 - ETA: >2024-05-24 19:31:20\n", + "2024-05-24 19:17:31 (UTC) - 0:19:20 - train - INFO - step: 000058 - done (%): 58.0 - loss: 0.840 - lr: 4.1e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3706.0 - avg_words_per_second: 3334.5 - ETA: >2024-05-24 19:31:16\n", + "2024-05-24 19:17:49 (UTC) - 0:19:38 - train - INFO - step: 000059 - done (%): 59.0 - loss: 0.836 - lr: 3.9e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3616.5 - avg_words_per_second: 3338.9 - ETA: >2024-05-24 19:31:14\n", + "2024-05-24 19:18:07 (UTC) - 0:19:56 - train - INFO - step: 000060 - done (%): 60.0 - loss: 0.852 - lr: 3.8e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3610.4 - avg_words_per_second: 3343.1 - ETA: >2024-05-24 19:31:11\n", + "2024-05-24 19:18:25 (UTC) - 0:20:14 - train - INFO - step: 000061 - done (%): 61.0 - loss: 0.837 - lr: 3.6e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3704.4 - avg_words_per_second: 3348.4 - ETA: >2024-05-24 19:31:08\n", + "2024-05-24 19:18:43 (UTC) - 0:20:32 - train - INFO - step: 000062 - done (%): 62.0 - loss: 0.839 - lr: 3.5e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3607.6 - avg_words_per_second: 3352.3 - ETA: >2024-05-24 19:31:06\n", + "2024-05-24 19:19:01 (UTC) - 0:20:50 - train - INFO - step: 000063 - done (%): 63.0 - loss: 0.813 - lr: 3.3e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3604.6 - avg_words_per_second: 3356.0 - ETA: >2024-05-24 19:31:04\n", + "2024-05-24 19:19:19 (UTC) - 0:21:08 - train - INFO - step: 000064 - done (%): 64.0 - loss: 0.784 - lr: 3.1e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3689.6 - avg_words_per_second: 3360.8 - ETA: >2024-05-24 19:31:01\n", + "2024-05-24 19:19:37 (UTC) - 0:21:26 - train - INFO - step: 000065 - done (%): 65.0 - loss: 0.797 - lr: 3.0e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3604.0 - avg_words_per_second: 3364.3 - ETA: >2024-05-24 19:30:59\n", + "2024-05-24 19:19:55 (UTC) - 0:21:44 - train - INFO - step: 000066 - done (%): 66.0 - loss: 0.788 - lr: 2.8e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3697.6 - avg_words_per_second: 3368.9 - ETA: >2024-05-24 19:30:56\n", + "2024-05-24 19:20:13 (UTC) - 0:22:02 - train - INFO - step: 000067 - done (%): 67.0 - loss: 0.902 - lr: 2.7e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3588.6 - avg_words_per_second: 3372.0 - ETA: >2024-05-24 19:30:55\n", + "2024-05-24 19:20:32 (UTC) - 0:22:20 - train - INFO - step: 000068 - done (%): 68.0 - loss: 0.783 - lr: 2.5e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3565.3 - avg_words_per_second: 3374.6 - ETA: >2024-05-24 19:30:53\n", + "2024-05-24 19:20:49 (UTC) - 0:22:38 - train - INFO - step: 000069 - done (%): 69.0 - loss: 0.889 - lr: 2.4e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3689.3 - avg_words_per_second: 3378.8 - ETA: >2024-05-24 19:30:51\n", + "2024-05-24 19:21:08 (UTC) - 0:22:56 - train - INFO - step: 000070 - done (%): 70.0 - loss: 0.810 - lr: 2.3e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3601.3 - avg_words_per_second: 3381.8 - ETA: >2024-05-24 19:30:49\n", + "2024-05-24 19:21:26 (UTC) - 0:23:14 - train - INFO - step: 000071 - done (%): 71.0 - loss: 0.796 - lr: 2.1e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3621.7 - avg_words_per_second: 3385.0 - ETA: >2024-05-24 19:30:47\n", + "2024-05-24 19:21:43 (UTC) - 0:23:32 - train - INFO - step: 000072 - done (%): 72.0 - loss: 0.927 - lr: 2.0e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3681.6 - avg_words_per_second: 3388.8 - ETA: >2024-05-24 19:30:45\n", + "2024-05-24 19:22:02 (UTC) - 0:23:50 - train - INFO - step: 000073 - done (%): 73.0 - loss: 0.811 - lr: 1.9e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3585.4 - avg_words_per_second: 3391.3 - ETA: >2024-05-24 19:30:44\n", + "2024-05-24 19:22:20 (UTC) - 0:24:08 - train - INFO - step: 000074 - done (%): 74.0 - loss: 0.828 - lr: 1.7e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3678.2 - avg_words_per_second: 3394.9 - ETA: >2024-05-24 19:30:42\n", + "2024-05-24 19:22:38 (UTC) - 0:24:26 - train - INFO - step: 000075 - done (%): 75.0 - loss: 0.908 - lr: 1.6e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3584.0 - avg_words_per_second: 3397.3 - ETA: >2024-05-24 19:30:40\n", + "2024-05-24 19:22:56 (UTC) - 0:24:45 - train - INFO - step: 000076 - done (%): 76.0 - loss: 0.881 - lr: 1.5e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3575.5 - avg_words_per_second: 3399.5 - ETA: >2024-05-24 19:30:39\n", + "2024-05-24 19:23:14 (UTC) - 0:25:03 - train - INFO - step: 000077 - done (%): 77.0 - loss: 0.819 - lr: 1.4e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3706.5 - avg_words_per_second: 3403.2 - ETA: >2024-05-24 19:30:37\n", + "2024-05-24 19:23:32 (UTC) - 0:25:21 - train - INFO - step: 000078 - done (%): 78.0 - loss: 0.867 - lr: 1.3e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3600.9 - avg_words_per_second: 3405.6 - ETA: >2024-05-24 19:30:35\n", + "2024-05-24 19:23:50 (UTC) - 0:25:38 - train - INFO - step: 000079 - done (%): 79.0 - loss: 0.913 - lr: 1.2e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3694.4 - avg_words_per_second: 3408.9 - ETA: >2024-05-24 19:30:34\n", + "2024-05-24 19:24:08 (UTC) - 0:25:57 - train - INFO - step: 000080 - done (%): 80.0 - loss: 0.826 - lr: 1.1e-05 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3603.8 - avg_words_per_second: 3411.2 - ETA: >2024-05-24 19:30:32\n", + "2024-05-24 19:24:26 (UTC) - 0:26:15 - train - INFO - step: 000081 - done (%): 81.0 - loss: 0.835 - lr: 9.5e-06 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3611.0 - avg_words_per_second: 3413.6 - ETA: >2024-05-24 19:30:31\n", + "2024-05-24 19:24:44 (UTC) - 0:26:33 - train - INFO - step: 000082 - done (%): 82.0 - loss: 0.854 - lr: 8.6e-06 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3686.5 - avg_words_per_second: 3416.7 - ETA: >2024-05-24 19:30:29\n", + "2024-05-24 19:25:02 (UTC) - 0:26:51 - train - INFO - step: 000083 - done (%): 83.0 - loss: 0.772 - lr: 7.7e-06 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3596.4 - avg_words_per_second: 3418.7 - ETA: >2024-05-24 19:30:28\n", + "2024-05-24 19:25:20 (UTC) - 0:27:09 - train - INFO - step: 000084 - done (%): 84.0 - loss: 0.813 - lr: 6.8e-06 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3607.9 - avg_words_per_second: 3420.9 - ETA: >2024-05-24 19:30:27\n", + "2024-05-24 19:25:38 (UTC) - 0:27:27 - train - INFO - step: 000085 - done (%): 85.0 - loss: 0.836 - lr: 6.0e-06 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3690.1 - avg_words_per_second: 3423.8 - ETA: >2024-05-24 19:30:25\n", + "2024-05-24 19:25:56 (UTC) - 0:27:45 - train - INFO - step: 000086 - done (%): 86.0 - loss: 0.866 - lr: 5.3e-06 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3607.4 - avg_words_per_second: 3425.8 - ETA: >2024-05-24 19:30:24\n", + "2024-05-24 19:26:14 (UTC) - 0:28:03 - train - INFO - step: 000087 - done (%): 87.0 - loss: 0.845 - lr: 4.6e-06 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3706.4 - avg_words_per_second: 3428.8 - ETA: >2024-05-24 19:30:22\n", + "2024-05-24 19:26:32 (UTC) - 0:28:21 - train - INFO - step: 000088 - done (%): 88.0 - loss: 0.777 - lr: 3.9e-06 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3591.4 - avg_words_per_second: 3430.6 - ETA: >2024-05-24 19:30:21\n", + "2024-05-24 19:26:51 (UTC) - 0:28:39 - train - INFO - step: 000089 - done (%): 89.0 - loss: 0.813 - lr: 3.3e-06 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3569.4 - avg_words_per_second: 3432.1 - ETA: >2024-05-24 19:30:21\n", + "2024-05-24 19:27:08 (UTC) - 0:28:57 - train - INFO - step: 000090 - done (%): 90.0 - loss: 0.841 - lr: 2.7e-06 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3697.1 - avg_words_per_second: 3434.8 - ETA: >2024-05-24 19:30:19\n", + "2024-05-24 19:27:26 (UTC) - 0:29:15 - train - INFO - step: 000091 - done (%): 91.0 - loss: 0.807 - lr: 2.2e-06 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3611.5 - avg_words_per_second: 3436.6 - ETA: >2024-05-24 19:30:18\n", + "2024-05-24 19:27:45 (UTC) - 0:29:33 - train - INFO - step: 000092 - done (%): 92.0 - loss: 0.807 - lr: 1.7e-06 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3607.2 - avg_words_per_second: 3438.4 - ETA: >2024-05-24 19:30:17\n", + "2024-05-24 19:28:02 (UTC) - 0:29:51 - train - INFO - step: 000093 - done (%): 93.0 - loss: 0.827 - lr: 1.3e-06 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3696.3 - avg_words_per_second: 3441.0 - ETA: >2024-05-24 19:30:16\n", + "2024-05-24 19:28:21 (UTC) - 0:30:09 - train - INFO - step: 000094 - done (%): 94.0 - loss: 0.816 - lr: 9.8e-07 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3583.1 - avg_words_per_second: 3442.5 - ETA: >2024-05-24 19:30:15\n", + "2024-05-24 19:28:38 (UTC) - 0:30:27 - train - INFO - step: 000095 - done (%): 95.0 - loss: 0.825 - lr: 6.8e-07 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3695.6 - avg_words_per_second: 3444.9 - ETA: >2024-05-24 19:30:13\n", + "2024-05-24 19:28:57 (UTC) - 0:30:45 - train - INFO - step: 000096 - done (%): 96.0 - loss: 0.794 - lr: 4.4e-07 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3580.1 - avg_words_per_second: 3446.3 - ETA: >2024-05-24 19:30:13\n", + "2024-05-24 19:29:15 (UTC) - 0:31:04 - train - INFO - step: 000097 - done (%): 97.0 - loss: 0.884 - lr: 2.5e-07 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3574.7 - avg_words_per_second: 3447.6 - ETA: >2024-05-24 19:30:12\n", + "2024-05-24 19:29:33 (UTC) - 0:31:21 - train - INFO - step: 000098 - done (%): 98.0 - loss: 0.826 - lr: 1.1e-07 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3698.8 - avg_words_per_second: 3450.0 - ETA: >2024-05-24 19:30:11\n", + "2024-05-24 19:29:51 (UTC) - 0:31:40 - train - INFO - step: 000099 - done (%): 99.0 - loss: 0.771 - lr: 2.8e-08 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 3604.2 - avg_words_per_second: 3451.5 - ETA: >2024-05-24 19:30:10\n", + "2024-05-24 19:30:09 (UTC) - 0:31:57 - eval - INFO - Start eval...\n", + "2024-05-24 19:32:04 (UTC) - 0:33:53 - eval - INFO - Eval finished!\n", + "2024-05-24 19:32:04 (UTC) - 0:33:53 - train - INFO - step: 000100 - eval_perplexity: 1.779 - eval_loss: 0.831 - train_loss: 0.762\n", + "2024-05-24 19:32:04 (UTC) - 0:33:53 - train - INFO - step: 000100 - done (%): 100.0 - loss: 0.762 - lr: 4.0e-10 - peak_alloc_mem (GB): 22.2 - alloc_mem (GB): 17.1 - words_per_second: 492.8 - avg_words_per_second: 3256.0 - ETA: >2024-05-24 19:32:04\n", + "2024-05-24 19:32:04 (UTC) - 0:33:53 - checkpointing - INFO - Dumping checkpoint in /content/test_ultra/checkpoints/checkpoint_000100/consolidated using tmp name: tmp.consolidated\n", + "2024-05-24 19:32:05 (UTC) - 0:33:53 - checkpointing - INFO - Done dumping checkpoint in /content/test_ultra/checkpoints/checkpoint_000100/consolidated for step: 100\n", + "2024-05-24 19:32:05 (UTC) - 0:33:53 - checkpointing - INFO - Done deleting checkpoints \n", + "2024-05-24 19:32:05 (UTC) - 0:33:53 - checkpointing - INFO - Done!\n", + "2024-05-24 19:32:05 (UTC) - 0:33:53 - train - INFO - done!\n", + "2024-05-24 19:32:05 (UTC) - 0:33:53 - utils - INFO - Closing: eval_logger\n", + "2024-05-24 19:32:05 (UTC) - 0:33:53 - utils - INFO - Closed: eval_logger\n", + "2024-05-24 19:32:05 (UTC) - 0:33:53 - utils - INFO - Closing: metrics_logger\n", + "2024-05-24 19:32:05 (UTC) - 0:33:53 - utils - INFO - Closed: metrics_logger\n", + "2024-05-24 19:32:05 (UTC) - 0:33:53 - train - INFO - Closed everything!\n" + ] + } + ] + }, + { + "cell_type": "markdown", + "source": [ + "## Inference" + ], + "metadata": { + "id": "ruJ29JFn98zE" + } + }, + { + "cell_type": "code", + "source": [ + "!pip install mistral_inference" + ], + "metadata": { + "id": "7BWNGKt9-Kxz", + "outputId": "61479b03-c608-455b-e99b-32d96ada9ca6", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 24, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Collecting mistral_inference\n", + " Downloading mistral_inference-1.1.0-py3-none-any.whl (21 kB)\n", + "Requirement already satisfied: fire>=0.6.0 in /usr/local/lib/python3.10/dist-packages (from mistral_inference) (0.6.0)\n", + "Requirement already satisfied: mistral_common<2.0.0,>=1.0.0 in /usr/local/lib/python3.10/dist-packages (from mistral_inference) (1.1.0)\n", + "Requirement already satisfied: safetensors>=0.4.0 in /usr/local/lib/python3.10/dist-packages (from mistral_inference) (0.4.3)\n", + "Requirement already satisfied: simple-parsing>=0.1.5 in /usr/local/lib/python3.10/dist-packages (from mistral_inference) (0.1.5)\n", + "Requirement already satisfied: xformers>=0.0.24 in /usr/local/lib/python3.10/dist-packages (from mistral_inference) (0.0.24)\n", + "Requirement already satisfied: six in /usr/local/lib/python3.10/dist-packages (from fire>=0.6.0->mistral_inference) (1.16.0)\n", + "Requirement already satisfied: termcolor in /usr/local/lib/python3.10/dist-packages (from fire>=0.6.0->mistral_inference) (2.4.0)\n", + "Requirement already satisfied: jsonschema==4.21.1 in /usr/local/lib/python3.10/dist-packages (from mistral_common<2.0.0,>=1.0.0->mistral_inference) (4.21.1)\n", + "Requirement already satisfied: pydantic==2.6.1 in /usr/local/lib/python3.10/dist-packages (from mistral_common<2.0.0,>=1.0.0->mistral_inference) (2.6.1)\n", + "Requirement already satisfied: sentencepiece==0.1.99 in /usr/local/lib/python3.10/dist-packages (from mistral_common<2.0.0,>=1.0.0->mistral_inference) (0.1.99)\n", + "Requirement already satisfied: typing-extensions<5.0.0,>=4.11.0 in /usr/local/lib/python3.10/dist-packages (from mistral_common<2.0.0,>=1.0.0->mistral_inference) (4.11.0)\n", + "Requirement already satisfied: attrs>=22.2.0 in /usr/local/lib/python3.10/dist-packages (from jsonschema==4.21.1->mistral_common<2.0.0,>=1.0.0->mistral_inference) (23.2.0)\n", + "Requirement already satisfied: jsonschema-specifications>=2023.03.6 in /usr/local/lib/python3.10/dist-packages (from jsonschema==4.21.1->mistral_common<2.0.0,>=1.0.0->mistral_inference) (2023.12.1)\n", + "Requirement already satisfied: referencing>=0.28.4 in /usr/local/lib/python3.10/dist-packages (from jsonschema==4.21.1->mistral_common<2.0.0,>=1.0.0->mistral_inference) (0.35.1)\n", + "Requirement already satisfied: rpds-py>=0.7.1 in /usr/local/lib/python3.10/dist-packages (from jsonschema==4.21.1->mistral_common<2.0.0,>=1.0.0->mistral_inference) (0.18.1)\n", + "Requirement already satisfied: annotated-types>=0.4.0 in /usr/local/lib/python3.10/dist-packages (from pydantic==2.6.1->mistral_common<2.0.0,>=1.0.0->mistral_inference) (0.7.0)\n", + "Requirement already satisfied: pydantic-core==2.16.2 in /usr/local/lib/python3.10/dist-packages (from pydantic==2.6.1->mistral_common<2.0.0,>=1.0.0->mistral_inference) (2.16.2)\n", + "Requirement already satisfied: docstring-parser~=0.15 in /usr/local/lib/python3.10/dist-packages (from simple-parsing>=0.1.5->mistral_inference) (0.16)\n", + "Requirement already satisfied: numpy in /usr/local/lib/python3.10/dist-packages (from xformers>=0.0.24->mistral_inference) (1.25.2)\n", + "Requirement already satisfied: torch==2.2.0 in /usr/local/lib/python3.10/dist-packages (from xformers>=0.0.24->mistral_inference) (2.2.0)\n", + "Requirement already satisfied: filelock in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (3.14.0)\n", + "Requirement already satisfied: sympy in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (1.12)\n", + "Requirement already satisfied: networkx in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (3.3)\n", + "Requirement already satisfied: jinja2 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (3.1.4)\n", + "Requirement already satisfied: fsspec in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (2023.6.0)\n", + "Requirement already satisfied: nvidia-cuda-nvrtc-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (12.1.105)\n", + "Requirement already satisfied: nvidia-cuda-runtime-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (12.1.105)\n", + "Requirement already satisfied: nvidia-cuda-cupti-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (12.1.105)\n", + "Requirement already satisfied: nvidia-cudnn-cu12==8.9.2.26 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (8.9.2.26)\n", + "Requirement already satisfied: nvidia-cublas-cu12==12.1.3.1 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (12.1.3.1)\n", + "Requirement already satisfied: nvidia-cufft-cu12==11.0.2.54 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (11.0.2.54)\n", + "Requirement already satisfied: nvidia-curand-cu12==10.3.2.106 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (10.3.2.106)\n", + "Requirement already satisfied: nvidia-cusolver-cu12==11.4.5.107 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (11.4.5.107)\n", + "Requirement already satisfied: nvidia-cusparse-cu12==12.1.0.106 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (12.1.0.106)\n", + "Requirement already satisfied: nvidia-nccl-cu12==2.19.3 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (2.19.3)\n", + "Requirement already satisfied: nvidia-nvtx-cu12==12.1.105 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (12.1.105)\n", + "Requirement already satisfied: triton==2.2.0 in /usr/local/lib/python3.10/dist-packages (from torch==2.2.0->xformers>=0.0.24->mistral_inference) (2.2.0)\n", + "Requirement already satisfied: nvidia-nvjitlink-cu12 in /usr/local/lib/python3.10/dist-packages (from nvidia-cusolver-cu12==11.4.5.107->torch==2.2.0->xformers>=0.0.24->mistral_inference) (12.5.40)\n", + "Requirement already satisfied: MarkupSafe>=2.0 in /usr/local/lib/python3.10/dist-packages (from jinja2->torch==2.2.0->xformers>=0.0.24->mistral_inference) (2.1.5)\n", + "Requirement already satisfied: mpmath>=0.19 in /usr/local/lib/python3.10/dist-packages (from sympy->torch==2.2.0->xformers>=0.0.24->mistral_inference) (1.3.0)\n", + "Installing collected packages: mistral_inference\n", + "Successfully installed mistral_inference-1.1.0\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [ + "from mistral_inference.model import Transformer\n", + "from mistral_inference.generate import generate\n", + "\n", + "from mistral_common.tokens.tokenizers.mistral import MistralTokenizer\n", + "from mistral_common.protocol.instruct.messages import UserMessage\n", + "from mistral_common.protocol.instruct.request import ChatCompletionRequest\n", + "\n", + "\n", + "tokenizer = MistralTokenizer.from_file(\"/content/mistral_models/tokenizer.model.v3\") # change to extracted tokenizer file\n", + "model = Transformer.from_folder(\"/content/mistral_models\") # change to extracted model dir\n", + "model.load_lora(\"/content/test_ultra/checkpoints/checkpoint_000100/consolidated/lora.safetensors\")\n", + "\n", + "completion_request = ChatCompletionRequest(messages=[UserMessage(content=\"Explain Machine Learning to me in a nutshell.\")])\n", + "\n", + "tokens = tokenizer.encode_chat_completion(completion_request).tokens\n", + "\n", + "out_tokens, _ = generate([tokens], model, max_tokens=64, temperature=0.0, eos_id=tokenizer.instruct_tokenizer.tokenizer.eos_id)\n", + "result = tokenizer.instruct_tokenizer.tokenizer.decode(out_tokens[0])\n", + "\n", + "print(result)" + ], + "metadata": { + "id": "F-xLs2Ot9-il", + "outputId": "f0c6f171-b14c-4d0c-d5e9-cb24a7f07653", + "colab": { + "base_uri": "https://localhost:8080/" + } + }, + "execution_count": 25, + "outputs": [ + { + "output_type": "stream", + "name": "stdout", + "text": [ + "Machine learning is a subset of artificial intelligence that involves the use of algorithms to learn from data and make predictions or decisions without being explicitly programmed. It is a type of computer science that enables machines to learn and improve from experience without being explicitly programmed. Machine learning algorithms can learn from data and make predictions or decisions based\n" + ] + } + ] + }, + { + "cell_type": "code", + "source": [], + "metadata": { + "id": "Vd8A8JP4Fx3C" + }, + "execution_count": null, + "outputs": [] + } + ] +} \ No newline at end of file diff --git a/utils/__init__.py b/utils/__init__.py new file mode 100644 index 0000000000000000000000000000000000000000..e69de29bb2d1d6434b8b29ae775ad8c2e48c5391 diff --git a/utils/__pycache__/__init__.cpython-38.pyc b/utils/__pycache__/__init__.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..60cb6407630284e3f11c7b99120c9804df6e39e3 Binary files /dev/null and b/utils/__pycache__/__init__.cpython-38.pyc differ diff --git a/utils/__pycache__/validate_data.cpython-38.pyc b/utils/__pycache__/validate_data.cpython-38.pyc new file mode 100644 index 0000000000000000000000000000000000000000..58b7e427ac573e1876968655c2e605fef36bd760 Binary files /dev/null and b/utils/__pycache__/validate_data.cpython-38.pyc differ diff --git a/utils/extend_model_vocab.py b/utils/extend_model_vocab.py new file mode 100644 index 0000000000000000000000000000000000000000..b22caf97fcc56ce2c922745830cb0e3e6f79f70e --- /dev/null +++ b/utils/extend_model_vocab.py @@ -0,0 +1,144 @@ +import argparse +import json +import math +import os +from pathlib import Path + +import torch +from mistral_common.tokens.tokenizers.mistral import MistralTokenizer +from mistral_common.tokens.tokenizers.sentencepiece import SentencePieceTokenizer + +from model.args import ModelArgs + +FIRST_PIECE_ID = 3 +OLD_VOCAB_SIZE = 32000 +NEW_VOCAB_SIZE = 32768 + + +def extend_model(original_model: Path, extended_model: Path): + original_ckpt = torch.load(str(original_model / "consolidated.00.pth"), mmap=True) + model_args = ModelArgs.load(str(original_model / "params.json")) + + original_vocab_size = model_args.vocab_size + assert ( + original_vocab_size == OLD_VOCAB_SIZE + ), f"Original vocab size {original_vocab_size} is not equal to 32000. Can only extend models with vocab_size of 32000" + + if not extended_model.exists(): + os.makedirs(extended_model, exist_ok=True) + print(f"Created empty directory {extended_model}.") + + assert not list( + extended_model.iterdir() + ), f"Make sure {extended_model} is empty" + + # Load and check tokenizers + mistral_tokenizer = MistralTokenizer.v3() + tokenizer: SentencePieceTokenizer = mistral_tokenizer.instruct_tokenizer.tokenizer + + new_vocab_size = tokenizer.n_words + assert ( + new_vocab_size == 32768 + ), f"New Tokenzier has vocab_size: {new_vocab_size} but has to be equal to 32768. Make sure to pass a v2 or v3 tokenizer file" + + vocabulary_delta = new_vocab_size - original_vocab_size + + # Check that 0...FIRST_PIECE_ID-1 are UNK + control characters and FIRST_PIECE_ID is the first piece + assert tokenizer._model.id_to_piece(vocabulary_delta + FIRST_PIECE_ID) == "<0x00>" + assert tokenizer._model.id_to_piece(FIRST_PIECE_ID - 1) == "" + + assert isinstance(tokenizer, SentencePieceTokenizer) + + original_embeddings = original_ckpt["tok_embeddings.weight"] + + assert ( + original_vocab_size == original_embeddings.shape[0] + ), f"Original vocab size {original_vocab_size} is not equal to original embeddings shape {original_embeddings.shape[0]}." + + dim = original_embeddings.shape[1] + + # Extend embeddings + extended_embeddings = torch.zeros( + tokenizer.n_words, dim, dtype=original_embeddings.dtype + ) + extended_embeddings[:original_vocab_size] = original_embeddings + extended_embeddings[:FIRST_PIECE_ID] = original_embeddings[:FIRST_PIECE_ID] + extended_embeddings[FIRST_PIECE_ID + vocabulary_delta :] = original_embeddings[ + FIRST_PIECE_ID: + ] + + # randomly initialize new tokens + extended_tokens = torch.empty( + vocabulary_delta, dim, dtype=original_embeddings.dtype + ) + torch.nn.init.normal_(extended_tokens, std=1 / math.sqrt(dim)) + + extended_embeddings[FIRST_PIECE_ID : FIRST_PIECE_ID + vocabulary_delta] = ( + extended_tokens + ) + + # Extend output + original_output = original_ckpt["output.weight"] + assert ( + original_output.shape[0] == original_vocab_size + ), f"Original output shape {original_output.shape[0]} is not equal to {original_vocab_size}." + assert ( + original_output.shape[1] == dim + ), f"Original output dim {original_output.shape[1]} is not equal to embedding dim {dim}." + + assert ( + original_output.dtype == original_embeddings.dtype + ), f"Original output and embeddings have different dtypes: {original_output.dtype} vs {original_embeddings.dtype}." + + extended_output = torch.zeros(tokenizer.n_words, dim, dtype=original_output.dtype) + extended_output[:FIRST_PIECE_ID] = original_output[:FIRST_PIECE_ID] + extended_output[FIRST_PIECE_ID + vocabulary_delta :] = original_output[ + FIRST_PIECE_ID: + ] + + # randomly initialize new tokens + extended_tokens = torch.empty(vocabulary_delta, dim, dtype=original_output.dtype) + torch.nn.init.normal_(extended_tokens, std=1 / math.sqrt(dim)) + + extended_output[FIRST_PIECE_ID : FIRST_PIECE_ID + vocabulary_delta] = ( + extended_tokens + ) + + original_ckpt["tok_embeddings.weight"] = extended_embeddings + original_ckpt["output.weight"] = extended_output + + new_ckpt_path = extended_model / "consolidated.00.pth" + print(f"Exporting extended model to {extended_model} ...") + torch.save(original_ckpt, new_ckpt_path) + + params_path = extended_model / "params.json" + with open(params_path, "w") as f: + model_dict = model_args.to_dict() + del model_dict["lora"] + if model_dict["moe"] is None: + del model_dict["moe"] + model_dict["vocab_size"] = new_vocab_size + + f.write(json.dumps(model_dict, indent=4)) + + +def main(): + parser = argparse.ArgumentParser( + description="Extend a model using the specified original model, extended model, and tokenizer paths." + ) + parser.add_argument( + "--original_model_ckpt", type=Path, help="Path to the original model folder." + ) + parser.add_argument( + "--extended_model_ckpt", type=Path, help="Path to the extended model file." + ) + args = parser.parse_args() + + extend_model( + original_model=args.original_model_ckpt, + extended_model=args.extended_model_ckpt, + ) + + +if __name__ == "__main__": + main() diff --git a/utils/merge_lora.py b/utils/merge_lora.py new file mode 100644 index 0000000000000000000000000000000000000000..4fce6909904320f031bdf8720483a589ff3897b2 --- /dev/null +++ b/utils/merge_lora.py @@ -0,0 +1,90 @@ +import argparse +from typing import Dict, Optional + +import safetensors.torch +import torch +import tqdm + + +def merge_checkpoints( + model_checkpoint: Dict[str, torch.Tensor], + lora_checkpoint: Dict[str, torch.Tensor], + scaling: float, + save_dtype: Optional[torch.dtype] = None, +): + save_dtype = save_dtype or next(iter(lora_checkpoint.values())).dtype + print(f"Merging to {save_dtype} precision...") + + keys_to_update = [ + key for key in lora_checkpoint.keys() if "norm" in key or "lora_A" in key + ] + assert any( + "lora_A" in k or "lora_B" in k for k in keys_to_update + ), "No `lora` keys found in your checkpoint. Check that `lora_ckpt` is correct." + + for key in tqdm.tqdm(keys_to_update): + if "norm" in key: + model_checkpoint[key] = lora_checkpoint[key].to("cpu") + else: + weight_name = key.replace("lora_A.weight", "weight") + + lora_A_weight = lora_checkpoint[key].to("cuda") + lora_B_weight = lora_checkpoint[key.replace("lora_A", "lora_B")].to("cuda") + + weight = lora_B_weight.mm(lora_A_weight) * scaling + weight += model_checkpoint[weight_name].to("cuda") + weight = weight.to(save_dtype) + + model_checkpoint[weight_name] = weight.to("cpu") + + # cast all tensors to save dtype + for key in tqdm.tqdm(model_checkpoint.keys()): + model_checkpoint[key] = model_checkpoint[key].to(save_dtype) + + +def load(filename: str): + if filename.endswith(".safetensors"): + return safetensors.torch.load_file(filename) + else: + return torch.load(filename) + + +def main(args): + model_checkpoint = load(args.initial_model_ckpt) + lora_checkpoint = load(args.lora_ckpt) + + merge_checkpoints(model_checkpoint, lora_checkpoint, args.scaling) + + safetensors.torch.save_file(model_checkpoint, args.dump_ckpt) + + print(f"Merged checkpoint saved to {args.dump_ckpt}") + + +if __name__ == "__main__": + parser = argparse.ArgumentParser( + description="Merge a LoRA checkpoint into a model checkpoint." + ) + parser.add_argument( + "--initial_model_ckpt", + type=str, + required=True, + help="Path to the model checkpoint.", + ) + parser.add_argument( + "--lora_ckpt", type=str, required=True, help="Path to the LoRA checkpoint." + ) + parser.add_argument( + "--dump_ckpt", + type=str, + required=True, + help="Path to save the merged checkpoint.", + ) + parser.add_argument( + "--scaling", + type=float, + default=2.0, + help="Scaling factor for the LoRA checkpoint. Default is 2.0.", + ) + + args = parser.parse_args() + main(args) diff --git a/utils/reformat_data.py b/utils/reformat_data.py new file mode 100755 index 0000000000000000000000000000000000000000..465abfabce65cff3af78a1d80d533bd5f46c1700 --- /dev/null +++ b/utils/reformat_data.py @@ -0,0 +1,88 @@ +#!/usr/bin/env python3 +import argparse +import json +import os +import random +import string + + +def reformat_jsonl(input_file): + output_file = input_file + ".tmp" + + content_keys = ["content", "text"] + with open(input_file, "r") as infile, open(output_file, "w") as outfile: + for idx, line in enumerate(infile): + data = json.loads(line) + if "functions" in data: + data["tools"] = [{"function": func} for func in data["functions"]] + del data["functions"] + + skip_sample = False + if "messages" in data: + for i, msg in enumerate(data["messages"]): + if "function_call" in msg: + if "content" in msg: + assert msg["content"] == "" + del msg["content"] + + arguments = json.loads(msg["function_call"]["arguments"]) + msg["function_call"]["arguments"] = json.dumps(arguments) + + msg["tool_calls"] = [{"function": msg.pop("function_call")}] + + for key in content_keys: + if key in msg and msg[key] == "": + if "tool_calls" in msg: + del msg[key] + print( + f"Delete empty '{key}' field in tool call message in line {idx}" + ) + + if all(msg.get(key) in ["", None] for key in content_keys): + # conversation is incorrect + skip_sample = True + + if msg["role"] in ["function", "tool"]: + msg["role"] = "tool" + if "tool_call_id" not in msg: + msg["tool_call_id"] = "".join( + random.choices( + string.ascii_letters + string.digits, k=9 + ) + ) + + # make sure prev + if data["messages"][i - 1]["role"] == "assistant": + prev_msg = data["messages"][i - 1] + if "tool_calls" in prev_msg: + tool_name = prev_msg["tool_calls"][0]["function"][ + "name" + ] + + assert tool_name == msg["name"] + prev_msg["tool_calls"][0]["id"] = msg["tool_call_id"] + + # make sure last message is an assistant message + while ( + len(data["messages"]) > 0 + and data["messages"][-1]["role"] != "assistant" + ): + data["messages"].pop() + + if len(data["messages"]) == 0: + skip_sample = True + + if not skip_sample: + outfile.write(json.dumps(data) + "\n") + else: + print(f"Skip {idx}th sample") + + os.rename(output_file, input_file) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Reformat a JSONL file.") + parser.add_argument("file", type=str, help="The input JSONL file") + + args = parser.parse_args() + reformat_jsonl(args.file) diff --git a/utils/reformat_data_glaive.py b/utils/reformat_data_glaive.py new file mode 100644 index 0000000000000000000000000000000000000000..0f908b64d03e2584dd18f62c94b34f4aaae9a293 --- /dev/null +++ b/utils/reformat_data_glaive.py @@ -0,0 +1,127 @@ +#!/usr/bin/env python3 +import argparse +import json +import os +import random +import string + + +def reformat_jsonl(input_file): # noqa: C901 + output_file = os.path.splitext(input_file)[0] + "_reformatted.jsonl" + skipped_samples = [] + + with open(input_file, "r") as infile, open(output_file, "w") as outfile: + for i, line in enumerate(infile): + reformat_data = True + data = json.loads(line) + + # Extract function description + try: + function_desc = json.loads(data["function_description"]) + except json.decoder.JSONDecodeError: + function_desc = ( + data["function_description"].replace("\n", "").replace("}{", "},{").replace("\\t", "") + ) + function_desc = "[{" + function_desc[1:-1] + "}]" + function_desc = json.loads(function_desc) + + function_desc = function_desc if isinstance(function_desc, list) else [function_desc] + + # Reformat tools section + if len(function_desc) == 1 and function_desc[0] == {}: + tools = None + else: + tools = [] + for f in function_desc: + if f["parameters"] is None: + f["parameters"] = {} + tools.append({"type": "function", "function": f}) + + messages = [] + + # Process conversations + for idx, msg in enumerate(data["conversations"]): + role = msg["from"] + content = msg["value"] + + if role == "system": + messages.append( + {"role": "system", "content": content.split(" -")[0]} + ) + elif role == "human": + messages.append({"role": "user", "content": content}) + elif role == "function-call": + try: + function_call = json.loads(content) + except json.decoder.JSONDecodeError: + content = content.replace("'", "").replace("\\", "'") + try: + function_call = json.loads(content) + except: # noqa: E722 + skipped_samples.append(str(i)) + reformat_data = False + break + + if not isinstance(function_call, list): + function_calls = [function_call] + else: + function_calls = function_call + + tool_calls = [] + for function_call in function_calls: + assert not isinstance(function_call, list) + tool_call_id = "".join( + random.choices(string.ascii_letters + string.digits, k=9) + ) + + if "arguments" in function_call and not isinstance(function_call["arguments"], str): + function_call["arguments"] = str(function_call["arguments"]) + elif "arguments" not in function_call: + function_call["arguments"] = "" + + tool_calls.append({"id": tool_call_id, "type": "function", "function": function_call}) + + messages.append( + { + "role": "assistant", + "tool_calls": tool_calls + } + ) + elif role == "function-response": + if "tool_calls" not in messages[-1]: + skipped_samples.append(str(i)) + reformat_data = False + break + + assert len(messages[-1]["tool_calls"]) == 1 + tool_call_id = messages[-1]["tool_calls"][0]["id"] + messages.append( + { + "role": "tool", + "content": content, + "tool_call_id": tool_call_id, + } + ) + elif role == "gpt": + messages.append({"role": "assistant", "content": content}) + + output_data = {"messages": messages} + + if tools is not None: + output_data["tools"] = tools + + if reformat_data: + outfile.write(json.dumps(output_data) + "\n") + + os.rename(output_file, input_file) + print( + f"Skipped {len(skipped_samples)} samples ({len(skipped_samples) / i:.2%}). The following samples are incorrectly formated: \n\n {', '.join(skipped_samples)}" + ) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Reformat a JSONL file.") + parser.add_argument("file", type=str, help="The input JSONL file") + + args = parser.parse_args() + reformat_jsonl(args.file) diff --git a/utils/validate_data.py b/utils/validate_data.py new file mode 100644 index 0000000000000000000000000000000000000000..8d8b686b240a63e08d8b3be053c0d7f47bb0e5dd --- /dev/null +++ b/utils/validate_data.py @@ -0,0 +1,366 @@ +import argparse +import json +from pathlib import Path +from typing import Dict + +from mistral_common.exceptions import ( + InvalidAssistantMessageException, + InvalidFunctionCallException, + InvalidMessageStructureException, + InvalidToolSchemaException, + TokenizerException, +) +from mistral_common.tokens.tokenizers.mistral import MistralTokenizer +from tqdm import tqdm + +from finetune.args import TrainArgs +from finetune.data.dataset import parse_data_sources +from finetune.data.tokenize import ( + ConversationFormatError, + FunctionFormatError, + MessageFormatError, + SampleType, + ToolCallFormatError, + UnrecognizedRoleError, + build_instruct_sample, + get_pretrain_sample, + tokenize, +) + +NUM_GPUS = 8 + +# EXPECTED WPS for batch_size = 32768 per GPU on H100 +EXPECTED_WPS = { + "open-mistral-7b": 5720, + "open-mixtral-8x7b": 2966, + "open-mixtral-8x22b": 1007, +} + +MIN_NUM_JSONL_LINES = 10 +MAX_NUM_JSONL_LINES = 10_000_000 + +MIN_BYTES = 1_000 +MAX_BYTES = 10_000_000_000 # rougly 10 GB + + +def convert_seconds_to_hms(seconds: float) -> str: + hours = int(seconds // 3600) + seconds %= 3600 + minutes = int(seconds // 60) + seconds %= 60 + + seconds = int(seconds) + return f"{hours:02d}:{minutes:02d}:{seconds:02d}" + + +def verify_size(jsonl_file: Path): + print(f"Verifying {jsonl_file} ...") + with jsonl_file.open() as f: + num_lines = 0 + num_bytes = 0 + for line in f: + num_lines += 1 + num_bytes += len(line) + + if num_lines < MIN_NUM_JSONL_LINES: + raise ValueError( + f"{jsonl_file} has only {num_lines} conversation which is less than the minimum amount of conversations required per dataset file: {MIN_NUM_JSONL_LINES}. Please make sure that each dataset has at least {MIN_NUM_JSONL_LINES} conversations." + ) + elif num_bytes < MIN_BYTES: + raise ValueError( + f"{jsonl_file} has only {num_bytes} bytes which is less than the minimum amount of bytes required per dataset file: {MIN_BYTES}. Please make sure that each dataset has at least {MIN_BYTES} bytes." + ) + elif num_lines > MAX_NUM_JSONL_LINES: + raise ValueError( + f"{jsonl_file} has {num_lines} conversation which is more than the maximum amount of allowed per dataset file: {MAX_NUM_JSONL_LINES}. Please make sure that each dataset has no more than {MAX_NUM_JSONL_LINES} conversations." + ) + elif num_bytes > MAX_BYTES: + raise ValueError( + f"{jsonl_file} has {num_bytes} bytes which is more than the maximum amount of bytes allowed per dataset file: {MAX_BYTES}. Please make sure that each dataset has no more than {MAX_BYTES} bytes." + ) + + print( + f"Dataset {jsonl_file} is valid. Dataset has {num_lines} conversations amounting to a total of {num_bytes} bytes." + ) + + +def get_train_stats( + num_tokens: Dict[str, int], + datasets_proportion: Dict[str, float], + train_args: TrainArgs, + return_type: str, +): + dataset_tokens = sum(num_tokens.values()) + batch_size = train_args.batch_size * train_args.seq_len * NUM_GPUS + + if Path(train_args.model_id_or_path).is_dir(): + params_config = json.load( + (Path(train_args.model_id_or_path) / "params.json").open() + ) + + if params_config["dim"] == 4096 and params_config.get("moe") is None: + model_id = "open-mistral-7b" + elif params_config["dim"] == 4096 and params_config.get("moe") is not None: + model_id = "open-mixtral-8x7b" + elif params_config["dim"] == 6144: + model_id = "open-mixtral-8x22b" + else: + raise ValueError("Provided model folder seems incorrect.") + else: + model_id = train_args.model_id_or_path + + wps = EXPECTED_WPS[model_id] + + if return_type == "expected": + train_tokens = train_args.max_steps * batch_size + max_steps = train_args.max_steps + num_epochs = train_tokens / dataset_tokens + elif return_type == "recommended": + num_epochs = 3 + max_steps = int(sum(num_tokens.values()) / batch_size * num_epochs) + train_tokens = max_steps * batch_size + else: + raise ValueError( + f"`return_type` is {return_type}, but has to be one of ['expected', 'recommended']" + ) + + expected_time_in_sec = train_tokens / NUM_GPUS / wps + + # Add 5min buffer for loading/init/ckpt/eval + expected_time_in_sec += 300 + + train_tokens_per_dataset = { + k: (train_tokens * v) for k, v in datasets_proportion.items() + } + + return { + "eta": convert_seconds_to_hms(expected_time_in_sec), + "data_tokens": dataset_tokens, + "train_tokens": train_tokens, + "epochs": f"{num_epochs:.2f}", + "max_steps": max_steps, + "data_tokens_per_dataset": {k: f"{v:.1f}" for k, v in num_tokens.items()}, + "train_tokens_per_dataset": { + k: f"{v:.1f}" for k, v in train_tokens_per_dataset.items() + }, + "epochs_per_dataset": { + k: f"{(train_tokens_per_dataset[k] / num_tokens[k]):.1f}" + for k in num_tokens.keys() + }, + } + + +def main(args): + train_args = TrainArgs.load(args.train_yaml) + + yaml_data_errors = [] + conversation_format_errors = [] + message_format_errors = [] + tokenization_errors = [] + + # Check if pretrain can be loaded + # train_pretrain_data = train_args.data.data + data = [("train", train_args.data.data, train_args.data.instruct_data)] + + if train_args.data.eval_instruct_data != "": + data.append(("eval", "", train_args.data.eval_instruct_data)) + + EXPECTED_WPS.keys() + + instruct_tokenizer = MistralTokenizer.v3().instruct_tokenizer + + for name, pretrain_file, instruct_file in data: + datasets, weights = parse_data_sources(pretrain_file, instruct_file) + data_types = [d.sample_type for d in datasets] + datasets = [str(d.path) for d in datasets] + + datasets_proportion = dict(zip(datasets, weights)) + num_tokens = {k: 0 for k in datasets_proportion} + + for data_type, dataset in tqdm(zip(data_types, datasets)): + # verify_size(Path(dataset)) + print(f"Validating {dataset} ...") + + corrected_dataset = dataset + ".corrected" + correct_lines = [] + + sub_yaml_data_errors = [] + sub_conversation_format_errors = [] + sub_message_format_errors = [] + sub_tokenization_errors = [] + + # Load the dataset + with open(dataset, "r", encoding="utf-8") as f: + lines = f.readlines() + for idx, line in tqdm(enumerate(lines), total=len(lines)): + try: + data = json.loads(line) + except ValueError as e: + prefix = f"The data in line {idx + 1} of dataset {dataset} is incorrectly formated." + sub_yaml_data_errors.append(prefix + str(e)) + continue + + if data_type == SampleType.PRETRAIN: + # TODO(Patrick) - Get good error message + sample = get_pretrain_sample(data) + else: + try: + sample = build_instruct_sample(data) + + except ( + ConversationFormatError, + UnrecognizedRoleError, + MessageFormatError, + ToolCallFormatError, + FunctionFormatError, + InvalidAssistantMessageException, + InvalidFunctionCallException, + InvalidMessageStructureException, + InvalidToolSchemaException, + ) as e: + prefix = f"The data in line {idx + 1} of dataset {dataset} is incorrectly formated." + if isinstance( + e, (ConversationFormatError, FunctionFormatError) + ): + sub_conversation_format_errors.append(prefix + str(e)) + elif isinstance( + e, + ( + MessageFormatError, + UnrecognizedRoleError, + ToolCallFormatError, + ), + ): + sub_message_format_errors.append(prefix + str(e)) + if isinstance( + e, + ( + InvalidFunctionCallException, + InvalidMessageStructureException, + InvalidAssistantMessageException, + InvalidToolSchemaException, + ), + ): + sub_conversation_format_errors.append(prefix + str(e)) + + continue + try: + tokens = tokenize(sample, instruct_tokenizer).tokens + except TokenizerException as e: + error_message = ( + f"The data in line {idx + 1} of dataset {dataset} could not be tokenized. " + + str(e) + ) + sub_tokenization_errors.append(error_message) + + correct_lines.append(line) + num_tokens[dataset] += len(tokens) + + is_sub_error = ( + len( + sub_yaml_data_errors + + sub_conversation_format_errors + + sub_message_format_errors + + sub_tokenization_errors + ) + > 0 + ) + if is_sub_error and args.create_corrected: + with open(corrected_dataset, "w", encoding="utf-8") as f: + for line in correct_lines: + f.write(line) + + print(f"Saved {corrected_dataset}.") + elif args.create_corrected: + print(f"No error in {dataset} - no need to create a corrected version.") + + yaml_data_errors.extend(sub_yaml_data_errors) + conversation_format_errors.extend(sub_conversation_format_errors) + message_format_errors.extend(sub_message_format_errors) + tokenization_errors.extend(sub_tokenization_errors) + + is_error = ( + len( + yaml_data_errors + + conversation_format_errors + + message_format_errors + + tokenization_errors + ) + > 0 + ) + if is_error: + all_yaml_data_errors = "\n".join(yaml_data_errors) + all_conversation_format_errors = "\n".join(conversation_format_errors) + all_message_format_errors = "\n".join(message_format_errors) + all_tokenization_errors = "\n".join(tokenization_errors) + error_report = f""" + Data error report + ----------------------- \n + The passed datasets contains some errors as listed below. Please make sure to fix these errors in order to start training. + + YAML data load errors: \n\n {all_yaml_data_errors} \n\n + Conversation format errors: \n\n {all_conversation_format_errors} \n\n + Message format errors: \n\n {all_message_format_errors} \n\n + Tokenization errors: \n\n {all_tokenization_errors} \n\n + """ + if args.save_reports: + with open(args.error_report_txt, "w") as f: + f.write(error_report) + + print(error_report) + else: + print("No errors! Data is correctly formated!") + + if name == "train" and not is_error: + expected_stats = get_train_stats( + num_tokens, datasets_proportion, train_args, return_type="expected" + ) + stats = { + "expected": expected_stats, + } + + filenames = ( + f"{instruct_file}" + if pretrain_file == "" + else f"{instruct_file} and {pretrain_file}" + ) + + print( + f"Stats for {filenames} \n {20 * '-'} \n {json.dumps(stats, indent=4)}" + ) + + if args.save_reports: + if name == "train": + with open(args.train_stats_json, "w") as file: + json.dump(stats, file, indent=4) + + +if __name__ == "__main__": + parser = argparse.ArgumentParser(description="Validate jsonl.") + parser.add_argument( + "--train_yaml", + type=str, + help="Path to the data file", + ) + parser.add_argument( + "--error_report_txt", + type=str, + default="data_errors.txt", + help="Path to the error report.", + ) + parser.add_argument( + "--train_stats_json", + type=str, + default="train_stats.json", + help="Path to training statistics json file.", + ) + parser.add_argument( + "--save_reports", action="store_true", help="Save reports to disk" + ) + parser.add_argument( + "--create_corrected", + action="store_true", + help="Skip faulty lines and append all correct lines to `.corrected` datasets.", + ) + args = parser.parse_args() + main(args)