gitarsenal-cli 1.9.76 → 1.9.78

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gitarsenal-cli",
-  "version": "1.9.76",
+  "version": "1.9.78",
   "description": "CLI tool for creating Modal sandboxes with GitHub repositories",
   "main": "index.js",
   "bin": {

package/python/credentials_manager.py

@@ -113,176 +113,7 @@ class CredentialsManager:
         except Exception as e:
             print(f"❌ Error getting input: {e}")
             return None
-    
-    def get_openai_api_key(self):
-        """Get OpenAI API key with validation - for user's repository execution"""
-        def validate_openai_key(key):
-            # Basic validation - OpenAI keys usually start with "sk-" and are 51 chars
-            return key.startswith("sk-") and len(key) > 40
-        
-        # First check stored credentials (user's key)
-        credentials = self.load_credentials()
-        if "openai_api_key" in credentials:
-            stored_key = credentials["openai_api_key"]
-            if validate_openai_key(stored_key):
-                return stored_key
-        
-        # Then check environment variable
-        env_key = os.environ.get("OPENAI_API_KEY")
-        if env_key and validate_openai_key(env_key):
-            return env_key
-            
-        # For user's repository execution, prompt if no key found
-        prompt = "An OpenAI API key is needed to run this repository.\nYou can get your API key from: https://platform.openai.com/api-keys"
-        return self.get_credential("openai_api_key", prompt, is_password=True, validate_func=validate_openai_key)
-    
-    def get_gitarsenal_openai_api_key(self):
-        """Get GitArsenal's OpenAI API key for debugging - never prompts user"""
-        def validate_openai_key(key):
-            # Basic validation - OpenAI keys usually start with "sk-" and are 51 chars
-            return key.startswith("sk-") and len(key) > 40
-        
-        # First try to fetch from server using fetch_modal_tokens (GitArsenal's key)
-        try:
-            from fetch_modal_tokens import get_tokens
-            _, _, api_key, _, _ = get_tokens()
-            if api_key and validate_openai_key(api_key):
-                # Set in environment for future use
-                os.environ["OPENAI_API_KEY"] = api_key
-                return api_key
-        except ImportError:
-            pass
-        except Exception as e:
-            print(f"⚠️ Error fetching GitArsenal API key from server: {e}")
-        
-        # Then check environment variable (for development/testing)
-        env_key = os.environ.get("GITARSENAL_OPENAI_API_KEY")
-        if env_key and validate_openai_key(env_key):
-            return env_key
-            
-        # Check for GitArsenal's key in credentials (for development)
-        credentials = self.load_credentials()
-        if "gitarsenal_openai_api_key" in credentials:
-            stored_key = credentials["gitarsenal_openai_api_key"]
-            if validate_openai_key(stored_key):
-                return stored_key
-        
-        # If no GitArsenal key found, return None (don't prompt user)
-        print("⚠️ GitArsenal's OpenAI API key not available for debugging")
-        return None
-    
-    def get_modal_token(self):
-        """Get Modal token with basic validation"""
-        # First check if we have a built-in token from setup_modal_token.py
-        try:
-            from setup_modal_token import BUILT_IN_MODAL_TOKEN
-            return BUILT_IN_MODAL_TOKEN
-        except ImportError:
-            pass
-        
-        # Fall back to credentials file if needed
-        credentials = self.load_credentials()
-        if "modal_token" in credentials:
-            return credentials["modal_token"]
-            
-        # Return the built-in token as a last resort
-        return "mo-abcdef1234567890abcdef1234567890"  # Same as in setup_modal_token.py
-    
-    def get_huggingface_token(self):
-        """Get Hugging Face token with basic validation"""
-        def validate_hf_token(token):
-            # HF tokens are typically non-empty strings
-            return bool(token) and len(token) > 8
-        
-        # First check stored credentials
-        credentials = self.load_credentials()
-        if "huggingface_token" in credentials:
-            stored_token = credentials["huggingface_token"]
-            if validate_hf_token(stored_token):
-                return stored_token
-            
-        prompt = "A Hugging Face token is required.\nYou can get your token from: https://huggingface.co/settings/tokens"
-        return self.get_credential("huggingface_token", prompt, is_password=True, validate_func=validate_hf_token)
-    
-    def get_wandb_api_key(self):
-        """Get Weights & Biases API key with validation"""
-        def validate_wandb_key(key):
-            # W&B API keys are typically 40 characters
-            return len(key) == 40
-        
-        # First check stored credentials
-        credentials = self.load_credentials()
-        if "wandb_api_key" in credentials:
-            stored_key = credentials["wandb_api_key"]
-            if validate_wandb_key(stored_key):
-                return stored_key
-            
-        prompt = "A Weights & Biases API key is required.\nYou can get your API key from: https://wandb.ai/authorize"
-        return self.get_credential("wandb_api_key", prompt, is_password=True, validate_func=validate_wandb_key)
-    
-    def get_anthropic_api_key(self):
-        """Get Anthropic API key with validation"""
-        def validate_anthropic_key(key):
-            # Anthropic keys usually start with "sk-ant-" and are typically 48+ characters
-            return key.startswith("sk-ant-") and len(key) > 40
-        
-        # First check stored credentials
-        credentials = self.load_credentials()
-        if "anthropic_api_key" in credentials:
-            stored_key = credentials["anthropic_api_key"]
-            if validate_anthropic_key(stored_key):
-                return stored_key
-        
-        # Then check environment variable
-        env_key = os.environ.get("ANTHROPIC_API_KEY")
-        if env_key and validate_anthropic_key(env_key):
-            return env_key
-            
-        prompt = "An Anthropic API key is required.\nYou can get your API key from: https://console.anthropic.com/"
-        return self.get_credential("anthropic_api_key", prompt, is_password=True, validate_func=validate_anthropic_key)
 
-    def get_groq_api_key(self):
-        """Get Groq API key with validation"""
-        def validate_groq_key(key):
-            # Groq keys are non-empty; basic length check
-            return bool(key) and len(key) > 20
-
-        # First check stored credentials
-        credentials = self.load_credentials()
-        if "groq_api_key" in credentials:
-            stored_key = credentials["groq_api_key"]
-            if validate_groq_key(stored_key):
-                return stored_key
-
-        # Then check environment variable
-        env_key = os.environ.get("GROQ_API_KEY")
-        if env_key and validate_groq_key(env_key):
-            return env_key
-
-        prompt = "A Groq API key is required for Groq models.\nYou can get your key from: https://console.groq.com/keys"
-        return self.get_credential("groq_api_key", prompt, is_password=True, validate_func=validate_groq_key)
-    
-    def get_exa_api_key(self):
-        """Get Exa API key with validation"""
-        def validate_exa_key(key):
-            # Exa API keys are typically 32+ characters
-            return len(key) >= 32
-        
-        # First check stored credentials
-        credentials = self.load_credentials()
-        if "exa_api_key" in credentials:
-            stored_key = credentials["exa_api_key"]
-            if validate_exa_key(stored_key):
-                return stored_key
-        
-        # Then check environment variable
-        env_key = os.environ.get("EXA_API_KEY")
-        if env_key and validate_exa_key(env_key):
-            return env_key
-            
-        prompt = "An Exa API key is required for web search functionality.\nYou can get your API key from: https://exa.ai/"
-        return self.get_credential("exa_api_key", prompt, is_password=True, validate_func=validate_exa_key)
-    
     def clear_credential(self, key):
         """Remove a specific credential"""
         credentials = self.load_credentials()

package/python/gitarsenal_keys.py

@@ -16,6 +16,7 @@ def main():
     parser.add_argument('command', choices=['add', 'list', 'view', 'delete'], help='Command to execute')
     parser.add_argument('--service', help='Service name (openai_api_key, WANDB_API_KEY, HUGGINGFACE_TOKEN, modal_token)')
     parser.add_argument('--key', help='API key (for add command)')
+    parser.add_argument('--json', action='store_true', help='Output in JSON format (for list command)')
     
     args = parser.parse_args()
     
@@ -25,7 +26,7 @@ def main():
     if args.command == 'add':
         handle_add(credentials_manager, args)
     elif args.command == 'list':
-        handle_list(credentials_manager)
+        handle_list(credentials_manager, args)
     elif args.command == 'view':
         handle_view(credentials_manager, args)
     elif args.command == 'delete':
@@ -94,10 +95,15 @@ def handle_add(credentials_manager, args):
         print("❌ Failed to save API key")
         sys.exit(1)
 
-def handle_list(credentials_manager):
+def handle_list(credentials_manager, args=None):
     """Handle listing all stored API keys"""
     credentials = credentials_manager.load_credentials()
     
+    if args and args.json:
+        # Return JSON format for programmatic access
+        print(json.dumps(credentials))
+        return
+    
     if not credentials:
         print("📭 No API keys stored")
         return

package/python/test_modalSandboxScript.py

@@ -46,21 +46,6 @@ def ssh_container_function(ssh_password=None, repo_url=None, repo_name=None, set
     import os
     import json
     import sys
-    import modal
-    
-    print("🐳 SSH Container Function Started!")
-    print(f"📋 Parameters received:")
-    print(f"   - SSH Password: {'***' if ssh_password else 'None'}")
-    print(f"   - Repo URL: {repo_url or 'None'}")
-    print(f"   - Repo Name: {repo_name or 'None'}")
-    print(f"   - Setup Commands: {len(setup_commands) if setup_commands else 0} commands")
-    print(f"   - OpenAI API Key: {'Set' if openai_api_key else 'Not set'}")
-    print(f"   - Anthropic API Key: {'Set' if anthropic_api_key else 'Not set'}")
-    print(f"   - Stored Credentials: {len(stored_credentials) if stored_credentials else 0} items")
-    
-    # Import only the modules we actually need (none currently for Agent-based approach)
-    # Note: CommandListManager and llm_debugging functions are not used in the Agent-based approach
-    print("✅ Container setup complete - using Agent-based repository setup")
     
     # Set root password
     subprocess.run(["bash", "-c", f"echo 'root:{ssh_password}' | chpasswd"], check=True)
@@ -113,7 +98,6 @@ def ssh_container_function(ssh_password=None, repo_url=None, repo_name=None, set
             os.environ['ANTHROPIC_API_KEY'] = anthropic_api_key
         
         # Set up Anthropic API key from stored credentials
-        anthropic_api_key = None
         if stored_credentials:
             # Look for Anthropic API key in various possible names
             for key_name in ['ANTHROPIC_API_KEY', 'anthropic_api_key', 'anthropic-api-key']:
@@ -566,35 +550,21 @@ def create_modal_ssh_container(gpu_type, repo_url=None, repo_name=None, setup_co
                 try:
                     # Wait for the function to start and print connection info (with timeout)
                     print("⏳ Waiting for container to initialize...")
-                    
-                    # Use a timeout to see if the container is starting properly
-                    print("🔍 Checking container status with 30-second timeout...")
                     try:
-                        result = function_call.get(timeout=30)
+                        print("\n⏳ Monitoring container (press Ctrl+C to stop monitoring)...")
+                        result = function_call.get()  # Wait indefinitely
                         print(f"🔚 Container function completed with result: {result}")
-                    except TimeoutError:
-                         print("⏰ Container is still running after 30 seconds - this is expected!")
-                         print("🎯 The container should be accessible via SSH now.")
-                         print("💡 The function will continue running until manually stopped.")
-                         print("🔗 Use Ctrl+C to stop monitoring, but the container will keep running.")
-                         print("🔒 Keeping tokens active since container is still running.")
-                         
-                         # Continue waiting for user interrupt
-                         try:
-                             print("\n⏳ Monitoring container (press Ctrl+C to stop monitoring)...")
-                             result = function_call.get()  # Wait indefinitely
-                             print(f"🔚 Container function completed with result: {result}")
-                         except KeyboardInterrupt:
-                             print("\n🛑 Stopped monitoring. Container is still running remotely.")
-                             print("💡 Use Modal's web UI or CLI to stop the container when done.")
-                             print("🔒 Keeping tokens active since container is still running.")
-                             return {
-                                 "app_name": app_name,
-                                 "ssh_password": ssh_password,
-                                 "volume_name": volume_name,
-                                 "status": "monitoring_stopped",
-                                 "function_call_id": function_call.object_id
-                             }
+                    except KeyboardInterrupt:
+                        print("\n🛑 Stopped monitoring. Container is still running remotely.")
+                        print("💡 Use Modal's web UI or CLI to stop the container when done.")
+                        print("🔒 Keeping tokens active since container is still running.")
+                        return {
+                            "app_name": app_name,
+                            "ssh_password": ssh_password,
+                            "volume_name": volume_name,
+                            "status": "monitoring_stopped",
+                            "function_call_id": function_call.object_id
+                        }
                              
                 except KeyboardInterrupt:
                     print("\n🛑 Interrupted by user. Container may still be running remotely.")

package/kill_claude/nanoGPT/.gitattributes

@@ -1,3 +0,0 @@
-# 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

@@ -1,21 +0,0 @@
-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

@@ -1,227 +0,0 @@
-
-# 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!