gitarsenal-cli 1.9.72 → 1.9.74

package/.venv_status.json

@@ -1 +1 @@
-{"created":"2025-08-15T05:36:26.751Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}
+{"created":"2025-08-15T09:19:17.108Z","packages":["modal","gitingest","requests","anthropic"],"uv_version":"uv 0.8.4 (Homebrew 2025-07-30)"}

package/bin/gitarsenal.js

@@ -747,7 +747,6 @@ async function runContainerCommand(options) {
     let gpuCount = parseInt(options.gpuCount) || 1;
     let volumeName = options.volumeName || options.volume;
     let skipConfirmation = options.yes;
-    let useApi = !options.manual;
     let setupCommands = options.setupCommands || [];
 
     if (!repoUrl) {
@@ -762,8 +761,8 @@ async function runContainerCommand(options) {
       repoUrl = answers.repoUrl;
     }
 
-    // Attempt full fetch first to get both commands and recommendations; now start preview concurrently
-    if (useApi && repoUrl) {
+    // Analyze repository for GPU recommendations (repository setup is now handled by Agent)
+    if (repoUrl) {
       // Start a main spinner that will show overall progress
       const mainSpinner = ora('Analyzing repository...').start();
       
@@ -783,11 +782,7 @@ async function runContainerCommand(options) {
           previewAbort.abort();
           mainSpinner.succeed('Analysis complete!');
           printGpuTorchCudaSummary(fullData);
-          if (Array.isArray(fullData.commands) && fullData.commands.length) {
-            setupCommands = fullData.commands;
-            // Disable auto-detection since we already have commands
-            useApi = false;
-          }
+          // Repository setup will be handled by Agent in container
         } else {
           // Full fetch failed, wait for preview and show its results
           mainSpinner.text = 'Waiting for preview analysis to complete...';
@@ -798,13 +793,13 @@ async function runContainerCommand(options) {
           } else {
             mainSpinner.fail('Analysis failed - both preview and full analysis timed out or failed');
             console.log(chalk.yellow('⚠️ Unable to analyze repository automatically.'));
-            console.log(chalk.gray('You can still proceed with manual setup commands.'));
+            console.log(chalk.gray('Repository setup will still be handled by Agent in container.'));
           }
         }
       } catch (error) {
         mainSpinner.fail(`Analysis failed: ${error.message}`);
         console.log(chalk.yellow('⚠️ Unable to analyze repository automatically.'));
-        console.log(chalk.gray('You can still proceed with manual setup commands.'));
+        console.log(chalk.gray('Repository setup will still be handled by Agent in container.'));
       }
     }
 
@@ -879,31 +874,14 @@ async function runContainerCommand(options) {
       volumeName = getDefaultVolumeName(repoUrl);
     }
 
-    // Ask about setup command detection if not specified via CLI
-    if (!options.manual && !options.yes && setupCommands.length === 0) {
-      const apiAnswers = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'useApi',
-          message: 'Automatically detect setup commands for this repository?',
-          default: true
-        }
-      ]);
-      
-      useApi = apiAnswers.useApi;
-    } else if (options.yes) {
-      // If --yes flag is used, default to using API for setup command detection
-      useApi = true;
-    }
-
-    // Only prompt for custom commands if auto-detection is disabled and no commands provided
-    if (!useApi && setupCommands.length === 0) {
+    // Prompt for custom setup commands only if no repo URL provided and no commands specified
+    if (!repoUrl && !options.manual && setupCommands.length === 0) {
       const setupAnswers = await inquirer.prompt([
         {
           type: 'confirm',
           name: 'useCustomCommands',
           message: 'Provide custom setup commands?',
-          default: true
+          default: false
         }
       ]);
 
@@ -953,7 +931,6 @@ async function runContainerCommand(options) {
         gpuCount,
         volumeName,
         setupCommands,
-        useApi,
         yes: skipConfirmation,
         userId,
         userName,

package/kill_claude/claude_code_agent.py

@@ -372,21 +372,10 @@ The following {len(TOOL_SCHEMAS)} tools are loaded and available:
                 
                 # Execute tool calls
                 if tool_calls:
-                    print(f"🤖 Agent requested {len(tool_calls)} tool call(s)")
                     tool_results = []
                     
                     for i, tool_call in enumerate(tool_calls, 1):
-                        print(f"--- Tool Call {i}/{len(tool_calls)} ---")
-                        result = self.execute_tool_call(tool_call)
-                        
-                        # Display the tool result
-                        if result and result.strip():
-                            print(f"📋 Tool Result:")
-                            print(result)
-                            print()  # Empty line for readability
-                        else:
-                            print("📋 Tool Result: (empty or no output)")
-                            print()
+                        result = self.execute_tool_call(tool_call, i, len(tool_calls))
                         
                         tool_results.append({
                             "tool_use_id": tool_call.id,
@@ -408,12 +397,14 @@ The following {len(TOOL_SCHEMAS)} tools are loaded and available:
         except Exception as e:
             return f"Error calling Anthropic API: {str(e)}"
     
-    def execute_tool_call(self, tool_call) -> str:
+    def execute_tool_call(self, tool_call, call_num: int = 1, total_calls: int = 1) -> str:
         """
         Execute a tool call using the loaded tool implementations.
         
         Args:
             tool_call: The tool call object from Claude
+            call_num: Current tool call number
+            total_calls: Total number of tool calls
             
         Returns:
             Tool execution result as string
@@ -421,27 +412,48 @@ The following {len(TOOL_SCHEMAS)} tools are loaded and available:
         tool_name = tool_call.name
         tool_input = tool_call.input
         
-        # Print tool usage information
-        print(f"🛠️  Using tool: {tool_name}")
+        # Print clean tool usage information like Claude Code
+        if total_calls > 1:
+            print(f"🛠️  Using tool: {tool_name}")
+        else:
+            print(f"🛠️  Using tool: {tool_name}")
+            
+        # Show parameters in a clean format
         if tool_input:
-            # Show key parameters (truncate long values)
             params_display = []
             for key, value in tool_input.items():
-                if isinstance(value, str) and len(value) > 50:
-                    params_display.append(f"{key}='{value[:50]}...'")
+                if isinstance(value, str) and len(value) > 80:
+                    params_display.append(f"{key}={value[:80]}...")
+                elif isinstance(value, list) and len(value) > 3:
+                    params_display.append(f"{key}=[{len(value)} items]")
                 else:
-                    params_display.append(f"{key}={repr(value)}")
+                    params_display.append(f"{key}={value}")
             print(f"   Parameters: {', '.join(params_display)}")
-        print()  # Empty line for readability
         
         try:
-            # Always use built-in implementations
+            # Execute the tool
             result = self._execute_builtin_tool(tool_name, tool_input)
-            print(f"✅ Tool {tool_name} completed successfully\n")
+            
+            # Print success message
+            print(f"\n✅ Tool {tool_name} completed successfully")
+            
+            # Print result in a clean format
+            if result and result.strip():
+                print(f"\n📋 Tool Result:")
+                # Truncate very long results for readability
+                if len(result) > 5000:
+                    print(result[:5000] + f"\n\n[Output truncated - showing first 5000 characters of {len(result)} total]")
+                else:
+                    print(result)
+            else:
+                print(f"\n📋 Tool Result: (no output)")
+            
+            print()  # Empty line for readability
             return result if result is not None else ""
                 
         except Exception as e:
-            print(f"❌ Tool {tool_name} failed: {str(e)}\n")
+            print(f"\n❌ Tool {tool_name} failed: {str(e)}")
+            print()
             return f"Error executing {tool_name}: {str(e)}"
     
     def _execute_builtin_tool(self, tool_name: str, tool_input: Dict[str, Any]) -> str:
@@ -511,19 +523,30 @@ The following {len(TOOL_SCHEMAS)} tools are loaded and available:
             # Apply offset and limit
             start_idx = (offset or 1) - 1
             end_idx = start_idx + (limit or len(lines))
-            lines = lines[start_idx:end_idx]
+            selected_lines = lines[start_idx:end_idx]
+            
+            # If file is empty, return empty indicator
+            if not lines:
+                return "<system-reminder>File exists but has empty contents</system-reminder>"
             
             # Format with line numbers like Claude Code
             formatted_lines = []
-            for i, line in enumerate(lines):
+            for i, line in enumerate(selected_lines):
                 line_num = start_idx + i + 1
                 # Remove trailing newline and truncate if too long
-                clean_line = line.rstrip('\n')
+                clean_line = line.rstrip('\n\r')
                 if len(clean_line) > 2000:
                     clean_line = clean_line[:2000] + "..."
                 formatted_lines.append(f"{line_num:>5}→{clean_line}")
             
-            return '\n'.join(formatted_lines)
+            # Add truncation note if we limited the output
+            result = '\n'.join(formatted_lines)
+            if limit and len(lines) > end_idx:
+                result += f"\n... (showing lines {start_idx + 1}-{end_idx} of {len(lines)} total lines)"
+            
+            return result
+        except UnicodeDecodeError:
+            return f"Cannot read file (binary or non-UTF-8 encoding): {file_path}"
         except Exception as e:
             return f"Error reading file: {str(e)}"
     
@@ -573,6 +596,10 @@ The following {len(TOOL_SCHEMAS)} tools are loaded and available:
             
             output_parts = []
             
+            # If command failed, show exit code first
+            if result.returncode != 0:
+                output_parts.append(f"Exit code: {result.returncode}")
+            
             # Add stdout if present
             if result.stdout and result.stdout.strip():
                 output_parts.append(result.stdout.strip())
@@ -581,16 +608,9 @@ The following {len(TOOL_SCHEMAS)} tools are loaded and available:
             if result.stderr and result.stderr.strip():
                 output_parts.append(result.stderr.strip())
             
-            # If command failed, include exit code
-            if result.returncode != 0:
-                if not output_parts:
-                    output_parts.append(f"Command failed with exit code {result.returncode}")
-                else:
-                    output_parts.insert(0, f"Exit code: {result.returncode}")
-            
-            # If no output at all but success, indicate success
+            # If no output at all but success, indicate success like Claude Code
             if not output_parts and result.returncode == 0:
-                output_parts.append("<system>Tool ran without output or errors</system>")
+                return "<system>Tool ran without output or errors</system>"
             
             return "\n".join(output_parts)
             
@@ -744,7 +764,8 @@ The following {len(TOOL_SCHEMAS)} tools are loaded and available:
                 
                 print("🤖 Claude Code Agent:")
                 response = self.process_query(user_input)
-                print(response)
+                if response.strip():
+                    print(response)
                 
             except KeyboardInterrupt:
                 print("\n\n👋 Goodbye!")

package/kill_claude/nanoGPT/.gitattributes

@@ -0,0 +1,3 @@
+# Override jupyter in Github language stats for more accurate estimate of repo code languages
+# reference: https://github.com/github/linguist/blob/master/docs/overrides.md#generated-code
+*.ipynb linguist-generated

package/kill_claude/nanoGPT/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 Andrej Karpathy
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/kill_claude/nanoGPT/README.md

@@ -0,0 +1,227 @@
+
+# nanoGPT
+
+![nanoGPT](assets/nanogpt.jpg)
+
+The simplest, fastest repository for training/finetuning medium-sized GPTs. It is a rewrite of [minGPT](https://github.com/karpathy/minGPT) that prioritizes teeth over education. Still under active development, but currently the file `train.py` reproduces GPT-2 (124M) on OpenWebText, running on a single 8XA100 40GB node in about 4 days of training. The code itself is plain and readable: `train.py` is a ~300-line boilerplate training loop and `model.py` a ~300-line GPT model definition, which can optionally load the GPT-2 weights from OpenAI. That's it.
+
+![repro124m](assets/gpt2_124M_loss.png)
+
+Because the code is so simple, it is very easy to hack to your needs, train new models from scratch, or finetune pretrained checkpoints (e.g. biggest one currently available as a starting point would be the GPT-2 1.3B model from OpenAI).
+
+## install
+
+```
+pip install torch numpy transformers datasets tiktoken wandb tqdm
+```
+
+Dependencies:
+
+- [pytorch](https://pytorch.org) <3
+- [numpy](https://numpy.org/install/) <3
+-  `transformers` for huggingface transformers <3 (to load GPT-2 checkpoints)
+-  `datasets` for huggingface datasets <3 (if you want to download + preprocess OpenWebText)
+-  `tiktoken` for OpenAI's fast BPE code <3
+-  `wandb` for optional logging <3
+-  `tqdm` for progress bars <3
+
+## quick start
+
+If you are not a deep learning professional and you just want to feel the magic and get your feet wet, the fastest way to get started is to train a character-level GPT on the works of Shakespeare. First, we download it as a single (1MB) file and turn it from raw text into one large stream of integers:
+
+```sh
+python data/shakespeare_char/prepare.py
+```
+
+This creates a `train.bin` and `val.bin` in that data directory. Now it is time to train your GPT. The size of it very much depends on the computational resources of your system:
+
+**I have a GPU**. Great, we can quickly train a baby GPT with the settings provided in the [config/train_shakespeare_char.py](config/train_shakespeare_char.py) config file:
+
+```sh
+python train.py config/train_shakespeare_char.py
+```
+
+If you peek inside it, you'll see that we're training a GPT with a context size of up to 256 characters, 384 feature channels, and it is a 6-layer Transformer with 6 heads in each layer. On one A100 GPU this training run takes about 3 minutes and the best validation loss is 1.4697. Based on the configuration, the model checkpoints are being written into the `--out_dir` directory `out-shakespeare-char`. So once the training finishes we can sample from the best model by pointing the sampling script at this directory:
+
+```sh
+python sample.py --out_dir=out-shakespeare-char
+```
+
+This generates a few samples, for example:
+
+```
+ANGELO:
+And cowards it be strawn to my bed,
+And thrust the gates of my threats,
+Because he that ale away, and hang'd
+An one with him.
+
+DUKE VINCENTIO:
+I thank your eyes against it.
+
+DUKE VINCENTIO:
+Then will answer him to save the malm:
+And what have you tyrannous shall do this?
+
+DUKE VINCENTIO:
+If you have done evils of all disposition
+To end his power, the day of thrust for a common men
+That I leave, to fight with over-liking
+Hasting in a roseman.
+```
+
+lol  `¯\_(ツ)_/¯`. Not bad for a character-level model after 3 minutes of training on a GPU. Better results are quite likely obtainable by instead finetuning a pretrained GPT-2 model on this dataset (see finetuning section later).
+
+**I only have a macbook** (or other cheap computer). No worries, we can still train a GPT but we want to dial things down a notch. I recommend getting the bleeding edge PyTorch nightly ([select it here](https://pytorch.org/get-started/locally/) when installing) as it is currently quite likely to make your code more efficient. But even without it, a simple train run could look as follows:
+
+```sh
+python train.py config/train_shakespeare_char.py --device=cpu --compile=False --eval_iters=20 --log_interval=1 --block_size=64 --batch_size=12 --n_layer=4 --n_head=4 --n_embd=128 --max_iters=2000 --lr_decay_iters=2000 --dropout=0.0
+```
+
+Here, since we are running on CPU instead of GPU we must set both `--device=cpu` and also turn off PyTorch 2.0 compile with `--compile=False`. Then when we evaluate we get a bit more noisy but faster estimate (`--eval_iters=20`, down from 200), our context size is only 64 characters instead of 256, and the batch size only 12 examples per iteration, not 64. We'll also use a much smaller Transformer (4 layers, 4 heads, 128 embedding size), and decrease the number of iterations to 2000 (and correspondingly usually decay the learning rate to around max_iters with `--lr_decay_iters`). Because our network is so small we also ease down on regularization (`--dropout=0.0`). This still runs in about ~3 minutes, but gets us a loss of only 1.88 and therefore also worse samples, but it's still good fun:
+
+```sh
+python sample.py --out_dir=out-shakespeare-char --device=cpu
+```
+Generates samples like this:
+
+```
+GLEORKEN VINGHARD III:
+Whell's the couse, the came light gacks,
+And the for mought you in Aut fries the not high shee
+bot thou the sought bechive in that to doth groan you,
+No relving thee post mose the wear
+```
+
+Not bad for ~3 minutes on a CPU, for a hint of the right character gestalt. If you're willing to wait longer, feel free to tune the hyperparameters, increase the size of the network, the context length (`--block_size`), the length of training, etc.
+
+Finally, on Apple Silicon Macbooks and with a recent PyTorch version make sure to add `--device=mps` (short for "Metal Performance Shaders"); PyTorch then uses the on-chip GPU that can *significantly* accelerate training (2-3X) and allow you to use larger networks. See [Issue 28](https://github.com/karpathy/nanoGPT/issues/28) for more.
+
+## reproducing GPT-2
+
+A more serious deep learning professional may be more interested in reproducing GPT-2 results. So here we go - we first tokenize the dataset, in this case the [OpenWebText](https://openwebtext2.readthedocs.io/en/latest/), an open reproduction of OpenAI's (private) WebText:
+
+```sh
+python data/openwebtext/prepare.py
+```
+
+This downloads and tokenizes the [OpenWebText](https://huggingface.co/datasets/openwebtext) dataset. It will create a `train.bin` and `val.bin` which holds the GPT2 BPE token ids in one sequence, stored as raw uint16 bytes. Then we're ready to kick off training. To reproduce GPT-2 (124M) you'll want at least an 8X A100 40GB node and run:
+
+```sh
+torchrun --standalone --nproc_per_node=8 train.py config/train_gpt2.py
+```
+
+This will run for about 4 days using PyTorch Distributed Data Parallel (DDP) and go down to loss of ~2.85. Now, a GPT-2 model just evaluated on OWT gets a val loss of about 3.11, but if you finetune it it will come down to ~2.85 territory (due to an apparent domain gap), making the two models ~match.
+
+If you're in a cluster environment and you are blessed with multiple GPU nodes you can make GPU go brrrr e.g. across 2 nodes like:
+
+```sh
+# Run on the first (master) node with example IP 123.456.123.456:
+torchrun --nproc_per_node=8 --nnodes=2 --node_rank=0 --master_addr=123.456.123.456 --master_port=1234 train.py
+# Run on the worker node:
+torchrun --nproc_per_node=8 --nnodes=2 --node_rank=1 --master_addr=123.456.123.456 --master_port=1234 train.py
+```
+
+It is a good idea to benchmark your interconnect (e.g. iperf3). In particular, if you don't have Infiniband then also prepend `NCCL_IB_DISABLE=1` to the above launches. Your multinode training will work, but most likely _crawl_. By default checkpoints are periodically written to the `--out_dir`. We can sample from the model by simply `python sample.py`.
+
+Finally, to train on a single GPU simply run the `python train.py` script. Have a look at all of its args, the script tries to be very readable, hackable and transparent. You'll most likely want to tune a number of those variables depending on your needs.
+
+## baselines
+
+OpenAI GPT-2 checkpoints allow us to get some baselines in place for openwebtext. We can get the numbers as follows:
+
+```sh
+$ python train.py config/eval_gpt2.py
+$ python train.py config/eval_gpt2_medium.py
+$ python train.py config/eval_gpt2_large.py
+$ python train.py config/eval_gpt2_xl.py
+```
+
+and observe the following losses on train and val:
+
+| model | params | train loss | val loss |
+| ------| ------ | ---------- | -------- |
+| gpt2 | 124M         | 3.11  | 3.12     |
+| gpt2-medium | 350M  | 2.85  | 2.84     |
+| gpt2-large | 774M   | 2.66  | 2.67     |
+| gpt2-xl | 1558M     | 2.56  | 2.54     |
+
+However, we have to note that GPT-2 was trained on (closed, never released) WebText, while OpenWebText is just a best-effort open reproduction of this dataset. This means there is a dataset domain gap. Indeed, taking the GPT-2 (124M) checkpoint and finetuning on OWT directly for a while reaches loss down to ~2.85. This then becomes the more appropriate baseline w.r.t. reproduction.
+
+## finetuning
+
+Finetuning is no different than training, we just make sure to initialize from a pretrained model and train with a smaller learning rate. For an example of how to finetune a GPT on new text go to `data/shakespeare` and run `prepare.py` to download the tiny shakespeare dataset and render it into a `train.bin` and `val.bin`, using the OpenAI BPE tokenizer from GPT-2. Unlike OpenWebText this will run in seconds. Finetuning can take very little time, e.g. on a single GPU just a few minutes. Run an example finetuning like:
+
+```sh
+python train.py config/finetune_shakespeare.py
+```
+
+This will load the config parameter overrides in `config/finetune_shakespeare.py` (I didn't tune them much though). Basically, we initialize from a GPT2 checkpoint with `init_from` and train as normal, except shorter and with a small learning rate. If you're running out of memory try decreasing the model size (they are `{'gpt2', 'gpt2-medium', 'gpt2-large', 'gpt2-xl'}`) or possibly decreasing the `block_size` (context length). The best checkpoint (lowest validation loss) will be in the `out_dir` directory, e.g. in `out-shakespeare` by default, per the config file. You can then run the code in `sample.py --out_dir=out-shakespeare`:
+
+```
+THEODORE:
+Thou shalt sell me to the highest bidder: if I die,
+I sell thee to the first; if I go mad,
+I sell thee to the second; if I
+lie, I sell thee to the third; if I slay,
+I sell thee to the fourth: so buy or sell,
+I tell thee again, thou shalt not sell my
+possession.
+
+JULIET:
+And if thou steal, thou shalt not sell thyself.
+
+THEODORE:
+I do not steal; I sell the stolen goods.
+
+THEODORE:
+Thou know'st not what thou sell'st; thou, a woman,
+Thou art ever a victim, a thing of no worth:
+Thou hast no right, no right, but to be sold.
+```
+
+Whoa there, GPT, entering some dark place over there. I didn't really tune the hyperparameters in the config too much, feel free to try!
+
+## sampling / inference
+
+Use the script `sample.py` to sample either from pre-trained GPT-2 models released by OpenAI, or from a model you trained yourself. For example, here is a way to sample from the largest available `gpt2-xl` model:
+
+```sh
+python sample.py \
+    --init_from=gpt2-xl \
+    --start="What is the answer to life, the universe, and everything?" \
+    --num_samples=5 --max_new_tokens=100
+```
+
+If you'd like to sample from a model you trained, use the `--out_dir` to point the code appropriately. You can also prompt the model with some text from a file, e.g. ```python sample.py --start=FILE:prompt.txt```.
+
+## efficiency notes
+
+For simple model benchmarking and profiling, `bench.py` might be useful. It's identical to what happens in the meat of the training loop of `train.py`, but omits much of the other complexities.
+
+Note that the code by default uses [PyTorch 2.0](https://pytorch.org/get-started/pytorch-2.0/). At the time of writing (Dec 29, 2022) this makes `torch.compile()` available in the nightly release. The improvement from the one line of code is noticeable, e.g. cutting down iteration time from ~250ms / iter to 135ms / iter. Nice work PyTorch team!
+
+## todos
+
+- Investigate and add FSDP instead of DDP
+- Eval zero-shot perplexities on standard evals (e.g. LAMBADA? HELM? etc.)
+- Finetune the finetuning script, I think the hyperparams are not great
+- Schedule for linear batch size increase during training
+- Incorporate other embeddings (rotary, alibi)
+- Separate out the optim buffers from model params in checkpoints I think
+- Additional logging around network health (e.g. gradient clip events, magnitudes)
+- Few more investigations around better init etc.
+
+## troubleshooting
+
+Note that by default this repo uses PyTorch 2.0 (i.e. `torch.compile`). This is fairly new and experimental, and not yet available on all platforms (e.g. Windows). If you're running into related error messages try to disable this by adding `--compile=False` flag. This will slow down the code but at least it will run.
+
+For some context on this repository, GPT, and language modeling it might be helpful to watch my [Zero To Hero series](https://karpathy.ai/zero-to-hero.html). Specifically, the [GPT video](https://www.youtube.com/watch?v=kCc8FmEb1nY) is popular if you have some prior language modeling context.
+
+For more questions/discussions feel free to stop by **#nanoGPT** on Discord:
+
+[![](https://dcbadge.vercel.app/api/server/3zy8kqD9Cp?compact=true&style=flat)](https://discord.gg/3zy8kqD9Cp)
+
+## acknowledgements
+
+All nanoGPT experiments are powered by GPUs on [Lambda labs](https://lambdalabs.com), my favorite Cloud GPU provider. Thank you Lambda labs for sponsoring nanoGPT!

package/kill_claude/nanoGPT/bench.py

@@ -0,0 +1,117 @@
+"""
+A much shorter version of train.py for benchmarking
+"""
+import os
+from contextlib import nullcontext
+import numpy as np
+import time
+import torch
+from model import GPTConfig, GPT
+
+# -----------------------------------------------------------------------------
+batch_size = 12
+block_size = 1024
+bias = False
+real_data = True
+seed = 1337
+device = 'cuda' # examples: 'cpu', 'cuda', 'cuda:0', 'cuda:1', etc.
+dtype = 'bfloat16' if torch.cuda.is_available() and torch.cuda.is_bf16_supported() else 'float16' # 'float32' or 'bfloat16' or 'float16'
+compile = True # use PyTorch 2.0 to compile the model to be faster
+profile = False # use pytorch profiler, or just simple benchmarking?
+exec(open('configurator.py').read()) # overrides from command line or config file
+# -----------------------------------------------------------------------------
+
+torch.manual_seed(seed)
+torch.cuda.manual_seed(seed)
+torch.backends.cuda.matmul.allow_tf32 = True # allow tf32 on matmul
+torch.backends.cudnn.allow_tf32 = True # allow tf32 on cudnn
+device_type = 'cuda' if 'cuda' in device else 'cpu' # for later use in torch.autocast
+ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[dtype]
+ctx = nullcontext() if device_type == 'cpu' else torch.amp.autocast(device_type=device_type, dtype=ptdtype)
+
+# data loading init
+if real_data:
+    dataset = 'openwebtext'
+    data_dir = os.path.join('data', dataset)
+    train_data = np.memmap(os.path.join(data_dir, 'train.bin'), dtype=np.uint16, mode='r')
+    def get_batch(split):
+        data = train_data # note ignore split in benchmarking script
+        ix = torch.randint(len(data) - block_size, (batch_size,))
+        x = torch.stack([torch.from_numpy((data[i:i+block_size]).astype(np.int64)) for i in ix])
+        y = torch.stack([torch.from_numpy((data[i+1:i+1+block_size]).astype(np.int64)) for i in ix])
+        x, y = x.pin_memory().to(device, non_blocking=True), y.pin_memory().to(device, non_blocking=True)
+        return x, y
+else:
+    # alternatively, if fixed data is desired to not care about data loading
+    x = torch.randint(50304, (batch_size, block_size), device=device)
+    y = torch.randint(50304, (batch_size, block_size), device=device)
+    get_batch = lambda split: (x, y)
+
+# model init
+gptconf = GPTConfig(
+    block_size = block_size, # how far back does the model look? i.e. context size
+    n_layer = 12, n_head = 12, n_embd = 768, # size of the model
+    dropout = 0, # for determinism
+    bias = bias,
+)
+model = GPT(gptconf)
+model.to(device)
+
+optimizer = model.configure_optimizers(weight_decay=1e-2, learning_rate=1e-4, betas=(0.9, 0.95), device_type=device_type)
+
+if compile:
+    print("Compiling model...")
+    model = torch.compile(model) # pytorch 2.0
+
+if profile:
+    # useful docs on pytorch profiler:
+    # - tutorial https://pytorch.org/tutorials/intermediate/tensorboard_profiler_tutorial.html
+    # - api https://pytorch.org/docs/stable/profiler.html#torch.profiler.profile
+    wait, warmup, active = 5, 5, 5
+    num_steps = wait + warmup + active
+    with torch.profiler.profile(
+        activities=[torch.profiler.ProfilerActivity.CPU, torch.profiler.ProfilerActivity.CUDA],
+        schedule=torch.profiler.schedule(wait=wait, warmup=warmup, active=active, repeat=1),
+        on_trace_ready=torch.profiler.tensorboard_trace_handler('./bench_log'),
+        record_shapes=False,
+        profile_memory=False,
+        with_stack=False, # incurs an additional overhead, disable if not needed
+        with_flops=True,
+        with_modules=False, # only for torchscript models atm
+    ) as prof:
+
+        X, Y = get_batch('train')
+        for k in range(num_steps):
+            with ctx:
+                logits, loss = model(X, Y)
+            X, Y = get_batch('train')
+            optimizer.zero_grad(set_to_none=True)
+            loss.backward()
+            optimizer.step()
+            lossf = loss.item()
+            print(f"{k}/{num_steps} loss: {lossf:.4f}")
+
+            prof.step() # notify the profiler at end of each step
+
+else:
+
+    # simple benchmarking
+    torch.cuda.synchronize()
+    for stage, num_steps in enumerate([10, 20]): # burnin, then benchmark
+        t0 = time.time()
+        X, Y = get_batch('train')
+        for k in range(num_steps):
+            with ctx:
+                logits, loss = model(X, Y)
+            X, Y = get_batch('train')
+            optimizer.zero_grad(set_to_none=True)
+            loss.backward()
+            optimizer.step()
+            lossf = loss.item()
+            print(f"{k}/{num_steps} loss: {lossf:.4f}")
+        torch.cuda.synchronize()
+        t1 = time.time()
+        dt = t1-t0
+        mfu = model.estimate_mfu(batch_size * 1 * num_steps, dt)
+        if stage == 1:
+            print(f"time per iteration: {dt/num_steps*1000:.4f}ms, MFU: {mfu*100:.2f}%")

package/kill_claude/nanoGPT/config/eval_gpt2.py

@@ -0,0 +1,8 @@
+# evaluate the base gpt2
+# n_layer=12, n_head=12, n_embd=768
+# 124M parameters
+batch_size = 8
+eval_iters = 500 # use more iterations to get good estimate
+eval_only = True
+wandb_log = False
+init_from = 'gpt2'

package/kill_claude/nanoGPT/config/eval_gpt2_large.py

@@ -0,0 +1,8 @@
+# evaluate the base gpt2
+# n_layer=36, n_head=20, n_embd=1280
+# 774M parameters
+batch_size = 8
+eval_iters = 500 # use more iterations to get good estimate
+eval_only = True
+wandb_log = False
+init_from = 'gpt2-large'