Upload folder using huggingface_hub

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+sbhatt54/models--EleutherAI--pythia-2.8b/blobs/ab496f1c3fd79e3c749a9d5414136a2c8e4224f94eecb261970315cdb0f813fe filter=lfs diff=lfs merge=lfs -text

hf_gradio.py

@@ -0,0 +1,76 @@
+from transformers import AutoModelForCausalLM, AutoTokenizer
+import transformers
+from utils import get_local_dir,  pad_to_length
+
+import gradio as gr
+import torch
+
+def load_checkpoint(checkpoint_path):
+    model = AutoModelForCausalLM.from_pretrained(checkpoint_path)
+    tokenizer = AutoTokenizer.from_pretrained(checkpoint_path)
+    return model, tokenizer
+
+import gradio as gr
+import torch
+
+
+checkpoint_paths = {'full_policy':'/home/sbhatt54/direct-preference-optimization/.cache/sbhatt54/anthropic_dpo_phythia28/LATEST/policy.pt',
+                    'reference':'/home/sbhatt54/direct-preference-optimization/.cache/sbhatt54/anthropic_dpo_pythia28_2023-08-06_12-12-25_294354/LATEST/policy.pt',
+                    'all_but_two_last':'/home/sbhatt54/direct-preference-optimization/.cache/sbhatt54/all_but_two_last/LATEST/policy.pt',
+                    'all_but_three_last':'/home/sbhatt54/direct-preference-optimization/.cache/sbhatt54/all_but_three_last_2023-08-19_06-44-44_597545/LATEST/policy.pt',
+                    'all_but_last_basic':'/home/sbhatt54/direct-preference-optimization/.cache/sbhatt54/all_but_last_basic_2023-08-19_06-44-55_606332/LATEST/policy.pt',
+                    'all_but_last':'/home/sbhatt54/direct-preference-optimization/.cache/sbhatt54/all_but_last_2023-08-19_06-45-07_722235/LATEST/policy.pt'
+
+
+}
+
+options=['reference','full_policy','all_but_two_last','all_but_three_last','all_but_last_basic','all_but_last']
+
+policy_dtype = getattr(torch, 'float32')
+tokenizer = transformers.AutoTokenizer.from_pretrained('EleutherAI/pythia-2.8b', cache_dir=get_local_dir('.cache'))
+
+model = transformers.AutoModelForCausalLM.from_pretrained(
+        'EleutherAI/pythia-2.8b', cache_dir=get_local_dir('.cache'), low_cpu_mem_usage=True, torch_dtype=policy_dtype)
+
+
+if tokenizer.pad_token_id is None:
+    tokenizer.pad_token_id = tokenizer.eos_token_id
+
+def load_selected_checkpoint(options):
+   selected_path = checkpoint_paths[options]
+    
+   policy_state_dict = torch.load(selected_path, map_location='cpu')
+   step, metrics = policy_state_dict ['step_idx'], policy_state_dict ['metrics']
+   model.load_state_dict(policy_state_dict['state'])
+   return model
+   
+
+def generate_response(prompt, options):
+    model= load_selected_checkpoint(options)
+    prompt='\n\nHuman: ' + prompt + '\n\nAssistant:'
+    input =tokenizer(prompt, add_special_tokens=False)
+
+    for i,k in input.items():
+        input[i]=torch.LongTensor(k).unsqueeze(0)
+    
+    policy_output = model.generate(input['input_ids'], attention_mask=input['attention_mask'], max_length=512, do_sample=True, pad_token_id=tokenizer.pad_token_id)
+
+    policy_output = pad_to_length(policy_output, 512, tokenizer.pad_token_id)
+    
+    policy_output_decoded = tokenizer.batch_decode(policy_output, skip_special_tokens=True)
+
+    return policy_output_decoded
+
+
+
+
+
+
+iface = gr.Interface(
+    fn=generate_response,
+    inputs=[gr.inputs.Textbox(label="Prompt"), gr.inputs.Dropdown(choices=options, label="Select Checkpoint")],
+    outputs="text"
+)
+iface.launch(share=True)
+
+

sbhatt54/models--EleutherAI--pythia-2.8b/blobs/0204ed10c186a4c7c68f55dff8f26087a45898d6

@@ -0,0 +1,5 @@
+{
+  "bos_token": "<|endoftext|>",
+  "eos_token": "<|endoftext|>",
+  "unk_token": "<|endoftext|>"
+}

sbhatt54/models--EleutherAI--pythia-2.8b/blobs/490234a04b8fc9587db08c7dbc7d73f99152f697

@@ -0,0 +1,24 @@
+{
+  "architectures": [
+    "GPTNeoXForCausalLM"
+  ],
+  "bos_token_id": 0,
+  "eos_token_id": 0,
+  "hidden_act": "gelu",
+  "hidden_size": 2560,
+  "initializer_range": 0.02,
+  "intermediate_size": 10240,
+  "layer_norm_eps": 1e-05,
+  "max_position_embeddings": 2048,
+  "model_type": "gpt_neox",
+  "num_attention_heads": 32,
+  "num_hidden_layers": 32,
+  "rotary_emb_base": 10000,
+  "rotary_pct": 0.25,
+  "tie_word_embeddings": false,
+  "torch_dtype": "float16",
+  "transformers_version": "4.24.0",
+  "use_cache": true,
+  "use_parallel_residual": true,
+  "vocab_size": 50304
+}

sbhatt54/models--EleutherAI--pythia-2.8b/blobs/ab496f1c3fd79e3c749a9d5414136a2c8e4224f94eecb261970315cdb0f813fe

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab496f1c3fd79e3c749a9d5414136a2c8e4224f94eecb261970315cdb0f813fe
+size 5684693096

sbhatt54/models--EleutherAI--pythia-2.8b/blobs/f1860edb10f80bcaf7b023fce47c68a23b724c23

@@ -0,0 +1,9 @@
+{
+  "add_prefix_space": false,
+  "bos_token": "<|endoftext|>",
+  "eos_token": "<|endoftext|>",
+  "name_or_path": "EleutherAI/gpt-neox-20b",
+  "special_tokens_map_file": "/admin/home-hailey/.cache/huggingface/hub/models--EleutherAI--gpt-neox-20b/snapshots/4e49eadb5d14bd22f314ec3f45b69a87b88c7691/special_tokens_map.json",
+  "tokenizer_class": "GPTNeoXTokenizer",
+  "unk_token": "<|endoftext|>"
+}

sbhatt54/models--EleutherAI--pythia-2.8b/refs/main

@@ -0,0 +1 @@
+2a259cdd96a4beb1cdf467512e3904197345f6a9

sbhatt54/models--EleutherAI--pythia-2.8b/snapshots/2a259cdd96a4beb1cdf467512e3904197345f6a9/config.json

@@ -0,0 +1,24 @@
+{
+  "architectures": [
+    "GPTNeoXForCausalLM"
+  ],
+  "bos_token_id": 0,
+  "eos_token_id": 0,
+  "hidden_act": "gelu",
+  "hidden_size": 2560,
+  "initializer_range": 0.02,
+  "intermediate_size": 10240,
+  "layer_norm_eps": 1e-05,
+  "max_position_embeddings": 2048,
+  "model_type": "gpt_neox",
+  "num_attention_heads": 32,
+  "num_hidden_layers": 32,
+  "rotary_emb_base": 10000,
+  "rotary_pct": 0.25,
+  "tie_word_embeddings": false,
+  "torch_dtype": "float16",
+  "transformers_version": "4.24.0",
+  "use_cache": true,
+  "use_parallel_residual": true,
+  "vocab_size": 50304
+}

sbhatt54/models--EleutherAI--pythia-2.8b/snapshots/2a259cdd96a4beb1cdf467512e3904197345f6a9/model.safetensors

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ab496f1c3fd79e3c749a9d5414136a2c8e4224f94eecb261970315cdb0f813fe
+size 5684693096

sbhatt54/models--EleutherAI--pythia-2.8b/snapshots/2a259cdd96a4beb1cdf467512e3904197345f6a9/special_tokens_map.json

@@ -0,0 +1,5 @@
+{
+  "bos_token": "<|endoftext|>",
+  "eos_token": "<|endoftext|>",
+  "unk_token": "<|endoftext|>"
+}

sbhatt54/models--EleutherAI--pythia-2.8b/snapshots/2a259cdd96a4beb1cdf467512e3904197345f6a9/tokenizer_config.json

@@ -0,0 +1,9 @@
+{
+  "add_prefix_space": false,
+  "bos_token": "<|endoftext|>",
+  "eos_token": "<|endoftext|>",
+  "name_or_path": "EleutherAI/gpt-neox-20b",
+  "special_tokens_map_file": "/admin/home-hailey/.cache/huggingface/hub/models--EleutherAI--gpt-neox-20b/snapshots/4e49eadb5d14bd22f314ec3f45b69a87b88c7691/special_tokens_map.json",
+  "tokenizer_class": "GPTNeoXTokenizer",
+  "unk_token": "<|endoftext|>"
+}

utils.py

@@ -0,0 +1,175 @@
+import os
+import getpass
+from datetime import datetime
+import torch
+import random
+import numpy as np
+import torch.distributed as dist
+import inspect
+import importlib.util
+import socket
+import os
+from typing import Dict, Union, Type, List
+
+
+def get_open_port():
+    with socket.socket(socket.AF_INET, socket.SOCK_STREAM) as s:
+        s.bind(('', 0)) # bind to all interfaces and use an OS provided port
+        return s.getsockname()[1] # return only the port number
+
+
+def get_remote_file(remote_path, local_path=None):
+    hostname, path = remote_path.split(':')
+    local_hostname = socket.gethostname()
+    if hostname == local_hostname or hostname == local_hostname[:local_hostname.find('.')]:
+        return path
+    
+    if local_path is None:
+        local_path = path
+    # local_path = local_path.replace('/scr-ssd', '/scr')    
+    if os.path.exists(local_path):
+        return local_path
+    local_dir = os.path.dirname(local_path)
+    os.makedirs(local_dir, exist_ok=True)
+
+    print(f'Copying {hostname}:{path} to {local_path}')
+    os.system(f'scp {remote_path} {local_path}')
+    return local_path
+
+
+def rank0_print(*args, **kwargs):
+    """Print, but only on rank 0."""
+    if not dist.is_initialized() or dist.get_rank() == 0:
+        print(*args, **kwargs)
+
+
+def get_local_dir(prefixes_to_resolve: List[str]) -> str:
+    """Return the path to the cache directory for this user."""
+    for prefix in prefixes_to_resolve:
+        if os.path.exists(prefix):
+            return f"{prefix}/{getpass.getuser()}"
+    os.makedirs(prefix)
+    return f"{prefix}/{getpass.getuser()}"
+    
+
+def get_local_run_dir(exp_name: str, local_dirs: List[str]) -> str:
+    """Create a local directory to store outputs for this run, and return its path."""
+    now = datetime.now()
+    timestamp = now.strftime("%Y-%m-%d_%H-%M-%S_%f")
+    run_dir = f"{get_local_dir(local_dirs)}/{exp_name}_{timestamp}"
+    os.makedirs(run_dir, exist_ok=True)
+    return run_dir
+
+
+def slice_and_move_batch_for_device(batch: Dict, rank: int, world_size: int, device: str) -> Dict:
+    """Slice a batch into chunks, and move each chunk to the specified device."""
+    chunk_size = len(list(batch.values())[0]) // world_size
+    start = chunk_size * rank
+    end = chunk_size * (rank + 1)
+    sliced = {k: v[start:end] for k, v in batch.items()}
+    on_device = {k: (v.to(device) if isinstance(v, torch.Tensor) else v) for k, v in sliced.items()}
+    return on_device
+
+
+def pad_to_length(tensor: torch.Tensor, length: int, pad_value: Union[int, float], dim: int = -1) -> torch.Tensor:
+    if tensor.size(dim) >= length:
+        return tensor
+    else:
+        pad_size = list(tensor.shape)
+        pad_size[dim] = length - tensor.size(dim)
+        return torch.cat([tensor, pad_value * torch.ones(*pad_size, dtype=tensor.dtype, device=tensor.device)], dim=dim)
+
+
+def all_gather_if_needed(values: torch.Tensor, rank: int, world_size: int) -> torch.Tensor:
+    """Gather and stack/cat values from all processes, if there are multiple processes."""
+    if world_size == 1:
+        return values
+
+    all_values = [torch.empty_like(values).to(rank) for _ in range(world_size)]
+    dist.all_gather(all_values, values)
+    cat_function = torch.cat if values.dim() > 0 else torch.stack
+    return cat_function(all_values, dim=0)
+
+
+def formatted_dict(d: Dict) -> Dict:
+    """Format a dictionary for printing."""
+    return {k: (f"{v:.5g}" if type(v) == float else v) for k, v in d.items()}
+    
+
+def disable_dropout(model: torch.nn.Module):
+    """Disable dropout in a model."""
+    for module in model.modules():
+        if isinstance(module, torch.nn.Dropout):
+            module.p = 0
+
+
+def print_gpu_memory(rank: int = None, message: str = ''):
+    """Print the amount of GPU memory currently allocated for each GPU."""
+    if torch.cuda.is_available():
+        device_count = torch.cuda.device_count()
+        for i in range(device_count):
+            device = torch.device(f'cuda:{i}')
+            allocated_bytes = torch.cuda.memory_allocated(device)
+            if allocated_bytes == 0:
+                continue
+            print('*' * 40)
+            print(f'[{message} rank {rank} ] GPU {i}: {allocated_bytes / 1024**2:.2f} MB')
+        print('*' * 40)
+
+
+def get_block_class_from_model(model: torch.nn.Module, block_class_name: str) -> torch.nn.Module:
+    """Get the class of a block from a model, using the block's class name."""
+    for module in model.modules():
+        if module.__class__.__name__ == block_class_name:
+            return module.__class__
+    raise ValueError(f"Could not find block class {block_class_name} in model {model}")
+
+
+def get_block_class_from_model_class_and_block_name(model_class: Type, block_class_name: str) -> Type:
+    filepath = inspect.getfile(model_class)
+    assert filepath.endswith('.py'), f"Expected a .py file, got {filepath}"
+    assert os.path.exists(filepath), f"File {filepath} does not exist"
+    assert "transformers" in filepath, f"Expected a transformers model, got {filepath}"
+
+    module_name = filepath[filepath.find('transformers'):].replace('/', '.')[:-3]
+    print(f"Searching in file {filepath}, module {module_name} for class {block_class_name}")
+
+    # Load the module dynamically
+    spec = importlib.util.spec_from_file_location(module_name, filepath)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    # Get the class dynamically
+    class_ = getattr(module, block_class_name)
+    print(f"Found class {class_} in module {module_name}")
+    return class_
+
+
+def init_distributed(rank: int, world_size: int, master_addr: str = 'localhost', port: int = 12355, backend: str = 'nccl'):
+    print(rank, 'initializing distributed')
+    os.environ["MASTER_ADDR"] = master_addr
+    os.environ["MASTER_PORT"] = str(port)
+    dist.init_process_group(backend, rank=rank, world_size=world_size)
+    torch.cuda.set_device(rank)
+
+
+class TemporarilySeededRandom:
+    def __init__(self, seed):
+        """Temporarily set the random seed, and then restore it when exiting the context."""
+        self.seed = seed
+        self.stored_state = None
+        self.stored_np_state = None
+
+    def __enter__(self):
+        # Store the current random state
+        self.stored_state = random.getstate()
+        self.stored_np_state = np.random.get_state()
+
+        # Set the random seed
+        random.seed(self.seed)
+        np.random.seed(self.seed)
+
+    def __exit__(self, exc_type, exc_value, traceback):
+        # Restore the random state
+        random.setstate(self.stored_state)
+        np.random.set_state(self.stored_np_state)