File size: 66,838 Bytes
d67f29d | 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 | {"repo_id":"SuperAlignment","entity_id":"py:train_example","uri":"program://SuperAlignment/module/train_example#L1-L60","kind":"module","name":"train_example","path":"train_example.py","language":"python","start_line":1,"end_line":60,"context_start_line":1,"context_end_line":60,"code":"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torchvision.models import resnet18, resnet50 # Example models\n\n# Define the teacher (weak model) and student (strong model)\nteacher_model = resnet18(pretrained=True)\nstudent_model = resnet50(pretrained=True)\n\n\n# Custom Adaptive Confidence Distillation Loss\nclass AdaptiveConfidenceDistillationLoss(nn.Module):\n def __init__(self, temperature=1.0):\n super().__init__()\n self.temperature = temperature\n self.ce_loss = nn.CrossEntropyLoss()\n\n def forward(self, student_logits, teacher_logits, targets):\n # Soften probabilities\n soft_teacher_probs = F.softmax(teacher_logits / self.temperature, dim=1)\n soft_student_probs = F.log_softmax(student_logits / self.temperature, dim=1)\n\n # Calculate the KL Divergence for the soft targets\n distillation_loss = F.kl_div(\n soft_student_probs, soft_teacher_probs, reduction=\"batchmean\"\n )\n\n # Calculate the standard loss with hard targets\n hard_loss = self.ce_loss(student_logits, targets)\n\n # Adaptive weighting could be implemented here based on confidence\n # For simplicity, this example uses a fixed ratio\n return distillation_loss + hard_loss\n\n\n# Example Training Loop Skeleton\ndef train_model(student_model, teacher_model, dataloader, optimizer, device):\n student_model.train()\n teacher_model.eval() # Teacher model should be in eval mode\n\n loss_fn = AdaptiveConfidenceDistillationLoss(temperature=2.0)\n\n for inputs, labels in dataloader:\n inputs, labels = inputs.to(device), labels.to(device)\n\n optimizer.zero_grad()\n\n with torch.no_grad():\n teacher_outputs = teacher_model(inputs)\n\n student_outputs = student_model(inputs)\n\n loss = loss_fn(student_outputs, teacher_outputs, labels)\n loss.backward()\n optimizer.step()\n\n\n# Example usage\n# Assuming `dataloader`, `optimizer`, and `device` are defined\n# train_model(student_model, teacher_model, dataloader, optimizer, device)","source_hash":"1d853ce261864b7b90ca11a013e5ff6feff4aa1e87a9d5d20878083564c9aba6","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:train_example.AdaptiveConfidenceDistillationLoss","uri":"program://SuperAlignment/class/train_example.AdaptiveConfidenceDistillationLoss#L12-L33","kind":"class","name":"AdaptiveConfidenceDistillationLoss","path":"train_example.py","language":"python","start_line":12,"end_line":33,"context_start_line":1,"context_end_line":53,"code":"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torchvision.models import resnet18, resnet50 # Example models\n\n# Define the teacher (weak model) and student (strong model)\nteacher_model = resnet18(pretrained=True)\nstudent_model = resnet50(pretrained=True)\n\n\n# Custom Adaptive Confidence Distillation Loss\nclass AdaptiveConfidenceDistillationLoss(nn.Module):\n def __init__(self, temperature=1.0):\n super().__init__()\n self.temperature = temperature\n self.ce_loss = nn.CrossEntropyLoss()\n\n def forward(self, student_logits, teacher_logits, targets):\n # Soften probabilities\n soft_teacher_probs = F.softmax(teacher_logits / self.temperature, dim=1)\n soft_student_probs = F.log_softmax(student_logits / self.temperature, dim=1)\n\n # Calculate the KL Divergence for the soft targets\n distillation_loss = F.kl_div(\n soft_student_probs, soft_teacher_probs, reduction=\"batchmean\"\n )\n\n # Calculate the standard loss with hard targets\n hard_loss = self.ce_loss(student_logits, targets)\n\n # Adaptive weighting could be implemented here based on confidence\n # For simplicity, this example uses a fixed ratio\n return distillation_loss + hard_loss\n\n\n# Example Training Loop Skeleton\ndef train_model(student_model, teacher_model, dataloader, optimizer, device):\n student_model.train()\n teacher_model.eval() # Teacher model should be in eval mode\n\n loss_fn = AdaptiveConfidenceDistillationLoss(temperature=2.0)\n\n for inputs, labels in dataloader:\n inputs, labels = inputs.to(device), labels.to(device)\n\n optimizer.zero_grad()\n\n with torch.no_grad():\n teacher_outputs = teacher_model(inputs)\n\n student_outputs = student_model(inputs)\n\n loss = loss_fn(student_outputs, teacher_outputs, labels)","source_hash":"1d853ce261864b7b90ca11a013e5ff6feff4aa1e87a9d5d20878083564c9aba6","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:train_example.train_model","uri":"program://SuperAlignment/function/train_example.train_model#L37-L55","kind":"function","name":"train_model","path":"train_example.py","language":"python","start_line":37,"end_line":55,"context_start_line":17,"context_end_line":60,"code":"\n def forward(self, student_logits, teacher_logits, targets):\n # Soften probabilities\n soft_teacher_probs = F.softmax(teacher_logits / self.temperature, dim=1)\n soft_student_probs = F.log_softmax(student_logits / self.temperature, dim=1)\n\n # Calculate the KL Divergence for the soft targets\n distillation_loss = F.kl_div(\n soft_student_probs, soft_teacher_probs, reduction=\"batchmean\"\n )\n\n # Calculate the standard loss with hard targets\n hard_loss = self.ce_loss(student_logits, targets)\n\n # Adaptive weighting could be implemented here based on confidence\n # For simplicity, this example uses a fixed ratio\n return distillation_loss + hard_loss\n\n\n# Example Training Loop Skeleton\ndef train_model(student_model, teacher_model, dataloader, optimizer, device):\n student_model.train()\n teacher_model.eval() # Teacher model should be in eval mode\n\n loss_fn = AdaptiveConfidenceDistillationLoss(temperature=2.0)\n\n for inputs, labels in dataloader:\n inputs, labels = inputs.to(device), labels.to(device)\n\n optimizer.zero_grad()\n\n with torch.no_grad():\n teacher_outputs = teacher_model(inputs)\n\n student_outputs = student_model(inputs)\n\n loss = loss_fn(student_outputs, teacher_outputs, labels)\n loss.backward()\n optimizer.step()\n\n\n# Example usage\n# Assuming `dataloader`, `optimizer`, and `device` are defined\n# train_model(student_model, teacher_model, dataloader, optimizer, device)","source_hash":"1d853ce261864b7b90ca11a013e5ff6feff4aa1e87a9d5d20878083564c9aba6","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:train_example.__init__","uri":"program://SuperAlignment/function/train_example.__init__#L13-L16","kind":"function","name":"__init__","path":"train_example.py","language":"python","start_line":13,"end_line":16,"context_start_line":1,"context_end_line":36,"code":"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torchvision.models import resnet18, resnet50 # Example models\n\n# Define the teacher (weak model) and student (strong model)\nteacher_model = resnet18(pretrained=True)\nstudent_model = resnet50(pretrained=True)\n\n\n# Custom Adaptive Confidence Distillation Loss\nclass AdaptiveConfidenceDistillationLoss(nn.Module):\n def __init__(self, temperature=1.0):\n super().__init__()\n self.temperature = temperature\n self.ce_loss = nn.CrossEntropyLoss()\n\n def forward(self, student_logits, teacher_logits, targets):\n # Soften probabilities\n soft_teacher_probs = F.softmax(teacher_logits / self.temperature, dim=1)\n soft_student_probs = F.log_softmax(student_logits / self.temperature, dim=1)\n\n # Calculate the KL Divergence for the soft targets\n distillation_loss = F.kl_div(\n soft_student_probs, soft_teacher_probs, reduction=\"batchmean\"\n )\n\n # Calculate the standard loss with hard targets\n hard_loss = self.ce_loss(student_logits, targets)\n\n # Adaptive weighting could be implemented here based on confidence\n # For simplicity, this example uses a fixed ratio\n return distillation_loss + hard_loss\n\n\n# Example Training Loop Skeleton","source_hash":"1d853ce261864b7b90ca11a013e5ff6feff4aa1e87a9d5d20878083564c9aba6","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:train_example.forward","uri":"program://SuperAlignment/function/train_example.forward#L18-L33","kind":"function","name":"forward","path":"train_example.py","language":"python","start_line":18,"end_line":33,"context_start_line":1,"context_end_line":53,"code":"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torchvision.models import resnet18, resnet50 # Example models\n\n# Define the teacher (weak model) and student (strong model)\nteacher_model = resnet18(pretrained=True)\nstudent_model = resnet50(pretrained=True)\n\n\n# Custom Adaptive Confidence Distillation Loss\nclass AdaptiveConfidenceDistillationLoss(nn.Module):\n def __init__(self, temperature=1.0):\n super().__init__()\n self.temperature = temperature\n self.ce_loss = nn.CrossEntropyLoss()\n\n def forward(self, student_logits, teacher_logits, targets):\n # Soften probabilities\n soft_teacher_probs = F.softmax(teacher_logits / self.temperature, dim=1)\n soft_student_probs = F.log_softmax(student_logits / self.temperature, dim=1)\n\n # Calculate the KL Divergence for the soft targets\n distillation_loss = F.kl_div(\n soft_student_probs, soft_teacher_probs, reduction=\"batchmean\"\n )\n\n # Calculate the standard loss with hard targets\n hard_loss = self.ce_loss(student_logits, targets)\n\n # Adaptive weighting could be implemented here based on confidence\n # For simplicity, this example uses a fixed ratio\n return distillation_loss + hard_loss\n\n\n# Example Training Loop Skeleton\ndef train_model(student_model, teacher_model, dataloader, optimizer, device):\n student_model.train()\n teacher_model.eval() # Teacher model should be in eval mode\n\n loss_fn = AdaptiveConfidenceDistillationLoss(temperature=2.0)\n\n for inputs, labels in dataloader:\n inputs, labels = inputs.to(device), labels.to(device)\n\n optimizer.zero_grad()\n\n with torch.no_grad():\n teacher_outputs = teacher_model(inputs)\n\n student_outputs = student_model(inputs)\n\n loss = loss_fn(student_outputs, teacher_outputs, labels)","source_hash":"1d853ce261864b7b90ca11a013e5ff6feff4aa1e87a9d5d20878083564c9aba6","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:AdaptiveConfidenceDistillation","uri":"program://SuperAlignment/module/AdaptiveConfidenceDistillation#L1-L27","kind":"module","name":"AdaptiveConfidenceDistillation","path":"AdaptiveConfidenceDistillation.py","language":"python","start_line":1,"end_line":27,"context_start_line":1,"context_end_line":27,"code":"import torch.nn as nn\nimport torch.nn.functional as F\n\n\n# Custom Adaptive Confidence Distillation Loss\nclass AdaptiveConfidenceDistillationLoss(nn.Module):\n def __init__(self, temperature=1.0):\n super().__init__()\n self.temperature = temperature\n self.ce_loss = nn.CrossEntropyLoss()\n\n def forward(self, student_logits, teacher_logits, targets):\n # Soften probabilities\n soft_teacher_probs = F.softmax(teacher_logits / self.temperature, dim=1)\n soft_student_probs = F.log_softmax(student_logits / self.temperature, dim=1)\n\n # Calculate the KL Divergence for the soft targets\n distillation_loss = F.kl_div(\n soft_student_probs, soft_teacher_probs, reduction=\"batchmean\"\n )\n\n # Calculate the standard loss with hard targets\n hard_loss = self.ce_loss(student_logits, targets)\n\n # Adaptive weighting could be implemented here based on confidence\n # For simplicity, this example uses a fixed ratio\n return distillation_loss + hard_loss","source_hash":"78f2354cb5ad0726bbf11cff4469be7a070132d3339921881ae5df2398b71f16","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:AdaptiveConfidenceDistillation.AdaptiveConfidenceDistillationLoss","uri":"program://SuperAlignment/class/AdaptiveConfidenceDistillation.AdaptiveConfidenceDistillationLoss#L6-L27","kind":"class","name":"AdaptiveConfidenceDistillationLoss","path":"AdaptiveConfidenceDistillation.py","language":"python","start_line":6,"end_line":27,"context_start_line":1,"context_end_line":27,"code":"import torch.nn as nn\nimport torch.nn.functional as F\n\n\n# Custom Adaptive Confidence Distillation Loss\nclass AdaptiveConfidenceDistillationLoss(nn.Module):\n def __init__(self, temperature=1.0):\n super().__init__()\n self.temperature = temperature\n self.ce_loss = nn.CrossEntropyLoss()\n\n def forward(self, student_logits, teacher_logits, targets):\n # Soften probabilities\n soft_teacher_probs = F.softmax(teacher_logits / self.temperature, dim=1)\n soft_student_probs = F.log_softmax(student_logits / self.temperature, dim=1)\n\n # Calculate the KL Divergence for the soft targets\n distillation_loss = F.kl_div(\n soft_student_probs, soft_teacher_probs, reduction=\"batchmean\"\n )\n\n # Calculate the standard loss with hard targets\n hard_loss = self.ce_loss(student_logits, targets)\n\n # Adaptive weighting could be implemented here based on confidence\n # For simplicity, this example uses a fixed ratio\n return distillation_loss + hard_loss","source_hash":"78f2354cb5ad0726bbf11cff4469be7a070132d3339921881ae5df2398b71f16","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:AdaptiveConfidenceDistillation.__init__","uri":"program://SuperAlignment/function/AdaptiveConfidenceDistillation.__init__#L7-L10","kind":"function","name":"__init__","path":"AdaptiveConfidenceDistillation.py","language":"python","start_line":7,"end_line":10,"context_start_line":1,"context_end_line":27,"code":"import torch.nn as nn\nimport torch.nn.functional as F\n\n\n# Custom Adaptive Confidence Distillation Loss\nclass AdaptiveConfidenceDistillationLoss(nn.Module):\n def __init__(self, temperature=1.0):\n super().__init__()\n self.temperature = temperature\n self.ce_loss = nn.CrossEntropyLoss()\n\n def forward(self, student_logits, teacher_logits, targets):\n # Soften probabilities\n soft_teacher_probs = F.softmax(teacher_logits / self.temperature, dim=1)\n soft_student_probs = F.log_softmax(student_logits / self.temperature, dim=1)\n\n # Calculate the KL Divergence for the soft targets\n distillation_loss = F.kl_div(\n soft_student_probs, soft_teacher_probs, reduction=\"batchmean\"\n )\n\n # Calculate the standard loss with hard targets\n hard_loss = self.ce_loss(student_logits, targets)\n\n # Adaptive weighting could be implemented here based on confidence\n # For simplicity, this example uses a fixed ratio\n return distillation_loss + hard_loss","source_hash":"78f2354cb5ad0726bbf11cff4469be7a070132d3339921881ae5df2398b71f16","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:AdaptiveConfidenceDistillation.forward","uri":"program://SuperAlignment/function/AdaptiveConfidenceDistillation.forward#L12-L27","kind":"function","name":"forward","path":"AdaptiveConfidenceDistillation.py","language":"python","start_line":12,"end_line":27,"context_start_line":1,"context_end_line":27,"code":"import torch.nn as nn\nimport torch.nn.functional as F\n\n\n# Custom Adaptive Confidence Distillation Loss\nclass AdaptiveConfidenceDistillationLoss(nn.Module):\n def __init__(self, temperature=1.0):\n super().__init__()\n self.temperature = temperature\n self.ce_loss = nn.CrossEntropyLoss()\n\n def forward(self, student_logits, teacher_logits, targets):\n # Soften probabilities\n soft_teacher_probs = F.softmax(teacher_logits / self.temperature, dim=1)\n soft_student_probs = F.log_softmax(student_logits / self.temperature, dim=1)\n\n # Calculate the KL Divergence for the soft targets\n distillation_loss = F.kl_div(\n soft_student_probs, soft_teacher_probs, reduction=\"batchmean\"\n )\n\n # Calculate the standard loss with hard targets\n hard_loss = self.ce_loss(student_logits, targets)\n\n # Adaptive weighting could be implemented here based on confidence\n # For simplicity, this example uses a fixed ratio\n return distillation_loss + hard_loss","source_hash":"78f2354cb5ad0726bbf11cff4469be7a070132d3339921881ae5df2398b71f16","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:test_train_example","uri":"program://SuperAlignment/module/test_train_example#L1-L42","kind":"module","name":"test_train_example","path":"test_train_example.py","language":"python","start_line":1,"end_line":42,"context_start_line":1,"context_end_line":42,"code":"import torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom torchvision.models import resnet18, resnet50\nfrom torch.utils.data import DataLoader, TensorDataset\nimport numpy as np\nfrom train_example import train_model\n\n# Define the teacher (weak model) and student (strong model)\nteacher_model = resnet18(pretrained=False) # Using pretrained=False for simplicity\nstudent_model = resnet50(pretrained=False)\n\n# Define a simple synthetic dataset resembling CIFAR-100\n# CIFAR-100 has 32x32 images with 3 channels\n# We'll create random data with similar dimensions\nnum_samples = 1000\ninput_channels = 3\ninput_height = 32\ninput_width = 32\nnum_classes = 100\n\n# Generate random images and labels\nimages = torch.randn(num_samples, input_channels, input_height, input_width)\nlabels = torch.randint(0, num_classes, (num_samples,))\n\n# Create DataLoader for the synthetic dataset\ndataset = TensorDataset(images, labels)\ndataloader = DataLoader(dataset, batch_size=32, shuffle=True)\n\n# Define optimizer and device\noptimizer = optim.Adam(student_model.parameters(), lr=0.001)\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n\n# Define a unit test function\ndef test_training_loop():\n train_model(student_model, teacher_model, dataloader, optimizer, device)\n\n\n# Run the test function\ntest_training_loop()\nprint(\"test passed!\")","source_hash":"6e808ad91b17c4e12df91f6ed188bfe810f9d6cb3ef55c61df0055a57b0abc0b","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:test_train_example.test_training_loop","uri":"program://SuperAlignment/function/test_train_example.test_training_loop#L36-L37","kind":"function","name":"test_training_loop","path":"test_train_example.py","language":"python","start_line":36,"end_line":37,"context_start_line":16,"context_end_line":42,"code":"num_samples = 1000\ninput_channels = 3\ninput_height = 32\ninput_width = 32\nnum_classes = 100\n\n# Generate random images and labels\nimages = torch.randn(num_samples, input_channels, input_height, input_width)\nlabels = torch.randint(0, num_classes, (num_samples,))\n\n# Create DataLoader for the synthetic dataset\ndataset = TensorDataset(images, labels)\ndataloader = DataLoader(dataset, batch_size=32, shuffle=True)\n\n# Define optimizer and device\noptimizer = optim.Adam(student_model.parameters(), lr=0.001)\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n\n# Define a unit test function\ndef test_training_loop():\n train_model(student_model, teacher_model, dataloader, optimizer, device)\n\n\n# Run the test function\ntest_training_loop()\nprint(\"test passed!\")","source_hash":"6e808ad91b17c4e12df91f6ed188bfe810f9d6cb3ef55c61df0055a57b0abc0b","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:dataset","uri":"program://SuperAlignment/module/dataset#L1-L58","kind":"module","name":"dataset","path":"dataset.py","language":"python","start_line":1,"end_line":58,"context_start_line":1,"context_end_line":58,"code":"import torch\nfrom torch.utils.data import Dataset\nimport os\nfrom PIL import Image\nfrom generate_labels import generate_label_for_single_image\nimport json\n\n\n# Custom Dataset Class\nclass CustomImageDataset(Dataset):\n def __init__(\n self, image_dir, transform=None, model_name=\"google/vit-base-patch16-224\"\n ):\n self.image_dir = image_dir\n self.transform = transform\n self.memory_bank = load_memory_bank() # Load existing labels from memory bank\n self.image_paths = [\n os.path.join(image_dir, img)\n for img in os.listdir(image_dir)\n if img.endswith((\".png\", \".jpg\", \".jpeg\"))\n ]\n self.model_name = model_name\n self.label_to_index = {} # Dynamically map labels to indices\n self.current_index = 0 # Keep track of the next index to assign\n\n def __len__(self):\n return len(self.image_paths)\n\n def __getitem__(self, idx):\n image_path = self.image_paths[idx]\n image = Image.open(image_path).convert(\"RGB\")\n\n if image_path not in self.memory_bank: # Check if label already exists\n # Generate label for the image\n _, predicted_label = generate_label_for_single_image(image_path)\n self.memory_bank[image_path] = predicted_label # Add to memory bank\n else:\n predicted_label = self.memory_bank[image_path] # Use existing label\n # if self.transform:\n # image = self.transform(image)\n\n # Dynamically assign index to new labels\n if predicted_label not in self.label_to_index:\n self.label_to_index[predicted_label] = self.current_index\n self.current_index += 1\n label_index = self.label_to_index[predicted_label]\n\n if self.transform:\n image = self.transform(image)\n return image, torch.tensor(label_index, dtype=torch.long)\n\n\ndef load_memory_bank(filename=\"label_memory_bank.json\"):\n if os.path.exists(filename):\n with open(filename, \"r\") as file:\n return json.load(file)\n else:\n return {}","source_hash":"981d68dd2e2858f57d74c1cd302ee09901a2fa38c665753fa9e6a5a0b08f1267","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:dataset.CustomImageDataset","uri":"program://SuperAlignment/class/dataset.CustomImageDataset#L10-L50","kind":"class","name":"CustomImageDataset","path":"dataset.py","language":"python","start_line":10,"end_line":50,"context_start_line":1,"context_end_line":58,"code":"import torch\nfrom torch.utils.data import Dataset\nimport os\nfrom PIL import Image\nfrom generate_labels import generate_label_for_single_image\nimport json\n\n\n# Custom Dataset Class\nclass CustomImageDataset(Dataset):\n def __init__(\n self, image_dir, transform=None, model_name=\"google/vit-base-patch16-224\"\n ):\n self.image_dir = image_dir\n self.transform = transform\n self.memory_bank = load_memory_bank() # Load existing labels from memory bank\n self.image_paths = [\n os.path.join(image_dir, img)\n for img in os.listdir(image_dir)\n if img.endswith((\".png\", \".jpg\", \".jpeg\"))\n ]\n self.model_name = model_name\n self.label_to_index = {} # Dynamically map labels to indices\n self.current_index = 0 # Keep track of the next index to assign\n\n def __len__(self):\n return len(self.image_paths)\n\n def __getitem__(self, idx):\n image_path = self.image_paths[idx]\n image = Image.open(image_path).convert(\"RGB\")\n\n if image_path not in self.memory_bank: # Check if label already exists\n # Generate label for the image\n _, predicted_label = generate_label_for_single_image(image_path)\n self.memory_bank[image_path] = predicted_label # Add to memory bank\n else:\n predicted_label = self.memory_bank[image_path] # Use existing label\n # if self.transform:\n # image = self.transform(image)\n\n # Dynamically assign index to new labels\n if predicted_label not in self.label_to_index:\n self.label_to_index[predicted_label] = self.current_index\n self.current_index += 1\n label_index = self.label_to_index[predicted_label]\n\n if self.transform:\n image = self.transform(image)\n return image, torch.tensor(label_index, dtype=torch.long)\n\n\ndef load_memory_bank(filename=\"label_memory_bank.json\"):\n if os.path.exists(filename):\n with open(filename, \"r\") as file:\n return json.load(file)\n else:\n return {}","source_hash":"981d68dd2e2858f57d74c1cd302ee09901a2fa38c665753fa9e6a5a0b08f1267","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:dataset.load_memory_bank","uri":"program://SuperAlignment/function/dataset.load_memory_bank#L53-L58","kind":"function","name":"load_memory_bank","path":"dataset.py","language":"python","start_line":53,"end_line":58,"context_start_line":33,"context_end_line":58,"code":" if image_path not in self.memory_bank: # Check if label already exists\n # Generate label for the image\n _, predicted_label = generate_label_for_single_image(image_path)\n self.memory_bank[image_path] = predicted_label # Add to memory bank\n else:\n predicted_label = self.memory_bank[image_path] # Use existing label\n # if self.transform:\n # image = self.transform(image)\n\n # Dynamically assign index to new labels\n if predicted_label not in self.label_to_index:\n self.label_to_index[predicted_label] = self.current_index\n self.current_index += 1\n label_index = self.label_to_index[predicted_label]\n\n if self.transform:\n image = self.transform(image)\n return image, torch.tensor(label_index, dtype=torch.long)\n\n\ndef load_memory_bank(filename=\"label_memory_bank.json\"):\n if os.path.exists(filename):\n with open(filename, \"r\") as file:\n return json.load(file)\n else:\n return {}","source_hash":"981d68dd2e2858f57d74c1cd302ee09901a2fa38c665753fa9e6a5a0b08f1267","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:dataset.__init__","uri":"program://SuperAlignment/function/dataset.__init__#L11-L24","kind":"function","name":"__init__","path":"dataset.py","language":"python","start_line":11,"end_line":24,"context_start_line":1,"context_end_line":44,"code":"import torch\nfrom torch.utils.data import Dataset\nimport os\nfrom PIL import Image\nfrom generate_labels import generate_label_for_single_image\nimport json\n\n\n# Custom Dataset Class\nclass CustomImageDataset(Dataset):\n def __init__(\n self, image_dir, transform=None, model_name=\"google/vit-base-patch16-224\"\n ):\n self.image_dir = image_dir\n self.transform = transform\n self.memory_bank = load_memory_bank() # Load existing labels from memory bank\n self.image_paths = [\n os.path.join(image_dir, img)\n for img in os.listdir(image_dir)\n if img.endswith((\".png\", \".jpg\", \".jpeg\"))\n ]\n self.model_name = model_name\n self.label_to_index = {} # Dynamically map labels to indices\n self.current_index = 0 # Keep track of the next index to assign\n\n def __len__(self):\n return len(self.image_paths)\n\n def __getitem__(self, idx):\n image_path = self.image_paths[idx]\n image = Image.open(image_path).convert(\"RGB\")\n\n if image_path not in self.memory_bank: # Check if label already exists\n # Generate label for the image\n _, predicted_label = generate_label_for_single_image(image_path)\n self.memory_bank[image_path] = predicted_label # Add to memory bank\n else:\n predicted_label = self.memory_bank[image_path] # Use existing label\n # if self.transform:\n # image = self.transform(image)\n\n # Dynamically assign index to new labels\n if predicted_label not in self.label_to_index:\n self.label_to_index[predicted_label] = self.current_index","source_hash":"981d68dd2e2858f57d74c1cd302ee09901a2fa38c665753fa9e6a5a0b08f1267","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:dataset.__len__","uri":"program://SuperAlignment/function/dataset.__len__#L26-L27","kind":"function","name":"__len__","path":"dataset.py","language":"python","start_line":26,"end_line":27,"context_start_line":6,"context_end_line":47,"code":"import json\n\n\n# Custom Dataset Class\nclass CustomImageDataset(Dataset):\n def __init__(\n self, image_dir, transform=None, model_name=\"google/vit-base-patch16-224\"\n ):\n self.image_dir = image_dir\n self.transform = transform\n self.memory_bank = load_memory_bank() # Load existing labels from memory bank\n self.image_paths = [\n os.path.join(image_dir, img)\n for img in os.listdir(image_dir)\n if img.endswith((\".png\", \".jpg\", \".jpeg\"))\n ]\n self.model_name = model_name\n self.label_to_index = {} # Dynamically map labels to indices\n self.current_index = 0 # Keep track of the next index to assign\n\n def __len__(self):\n return len(self.image_paths)\n\n def __getitem__(self, idx):\n image_path = self.image_paths[idx]\n image = Image.open(image_path).convert(\"RGB\")\n\n if image_path not in self.memory_bank: # Check if label already exists\n # Generate label for the image\n _, predicted_label = generate_label_for_single_image(image_path)\n self.memory_bank[image_path] = predicted_label # Add to memory bank\n else:\n predicted_label = self.memory_bank[image_path] # Use existing label\n # if self.transform:\n # image = self.transform(image)\n\n # Dynamically assign index to new labels\n if predicted_label not in self.label_to_index:\n self.label_to_index[predicted_label] = self.current_index\n self.current_index += 1\n label_index = self.label_to_index[predicted_label]\n","source_hash":"981d68dd2e2858f57d74c1cd302ee09901a2fa38c665753fa9e6a5a0b08f1267","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:dataset.__getitem__","uri":"program://SuperAlignment/function/dataset.__getitem__#L29-L50","kind":"function","name":"__getitem__","path":"dataset.py","language":"python","start_line":29,"end_line":50,"context_start_line":9,"context_end_line":58,"code":"# Custom Dataset Class\nclass CustomImageDataset(Dataset):\n def __init__(\n self, image_dir, transform=None, model_name=\"google/vit-base-patch16-224\"\n ):\n self.image_dir = image_dir\n self.transform = transform\n self.memory_bank = load_memory_bank() # Load existing labels from memory bank\n self.image_paths = [\n os.path.join(image_dir, img)\n for img in os.listdir(image_dir)\n if img.endswith((\".png\", \".jpg\", \".jpeg\"))\n ]\n self.model_name = model_name\n self.label_to_index = {} # Dynamically map labels to indices\n self.current_index = 0 # Keep track of the next index to assign\n\n def __len__(self):\n return len(self.image_paths)\n\n def __getitem__(self, idx):\n image_path = self.image_paths[idx]\n image = Image.open(image_path).convert(\"RGB\")\n\n if image_path not in self.memory_bank: # Check if label already exists\n # Generate label for the image\n _, predicted_label = generate_label_for_single_image(image_path)\n self.memory_bank[image_path] = predicted_label # Add to memory bank\n else:\n predicted_label = self.memory_bank[image_path] # Use existing label\n # if self.transform:\n # image = self.transform(image)\n\n # Dynamically assign index to new labels\n if predicted_label not in self.label_to_index:\n self.label_to_index[predicted_label] = self.current_index\n self.current_index += 1\n label_index = self.label_to_index[predicted_label]\n\n if self.transform:\n image = self.transform(image)\n return image, torch.tensor(label_index, dtype=torch.long)\n\n\ndef load_memory_bank(filename=\"label_memory_bank.json\"):\n if os.path.exists(filename):\n with open(filename, \"r\") as file:\n return json.load(file)\n else:\n return {}","source_hash":"981d68dd2e2858f57d74c1cd302ee09901a2fa38c665753fa9e6a5a0b08f1267","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:train","uri":"program://SuperAlignment/module/train#L1-L156","kind":"module","name":"train","path":"train.py","language":"python","start_line":1,"end_line":156,"context_start_line":1,"context_end_line":156,"code":"import torch\nimport torch.optim as optim\nfrom torchvision import transforms\nfrom torchvision.models import resnet18, resnet50\nfrom torch.utils.data import DataLoader\nimport numpy as np\nimport os\nimport json\nfrom utils import plot_and_save_metrics\nfrom dataset import CustomImageDataset\nfrom AdaptiveConfidenceDistillation import AdaptiveConfidenceDistillationLoss\n\n# Define the teacher (weak model) and student (strong model)\nteacher_model = resnet18(pretrained=True) # Using pretrained=False for simplicity\nstudent_model = resnet50(pretrained=True)\n\n# Define a simple synthetic dataset resembling CIFAR-100\n# CIFAR-100 has 32x32 images with 3 channels\n# We'll create random data with similar dimensions\nnum_samples = 1000\ninput_channels = 3\ninput_height = 32\ninput_width = 32\nnum_classes = 100\n\n# Define transformations\ntransform = transforms.Compose(\n [\n transforms.Resize((32, 32)),\n transforms.ToTensor(),\n ]\n)\n\n# Create an instance of the CustomImageDataset\nimage_dir = \"./images\" # Specify the correct path to your images\ndataset = CustomImageDataset(image_dir=image_dir, transform=transform)\n\n\ndef save_memory_bank(memory_bank, filename=\"label_memory_bank.json\"):\n with open(filename, \"w\") as file:\n json.dump(memory_bank, file)\n\n\n# After training is complete or when you're done using the dataset\nsave_memory_bank(dataset.memory_bank) # Save the updated memory bank to a file\n# Split dataset into train and validation sets\ntrain_size = int(0.8 * len(dataset))\nval_size = len(dataset) - train_size\ntrain_dataset, val_dataset = torch.utils.data.random_split(\n dataset, [train_size, val_size]\n)\n\n# Create DataLoaders\ntrain_dataloader = DataLoader(train_dataset, batch_size=32, shuffle=True)\nval_dataloader = DataLoader(val_dataset, batch_size=32, shuffle=False)\n\n# Define optimizer and device\noptimizer = optim.Adam(student_model.parameters(), lr=0.001)\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nprint(f\"Using device: {device}\")\n\n\n# Step 1: Load Labels and Image Paths\ndef load_image_paths_labels(json_path):\n with open(json_path, \"r\") as f:\n data = json.load(f)\n image_paths = [os.path.join(\"./images\", item[\"image_path\"]) for item in data]\n labels = [item[\"caption\"] for item in data]\n return image_paths, labels\n\n\n# Example Training Loop Skeleton with Validation and Model Checkpointing\ndef train_model_with_validation(\n student_model,\n teacher_model,\n train_dataloader,\n val_dataloader,\n optimizer,\n device,\n num_epochs=10,\n checkpoint_path=\"checkpoint.pth\",\n):\n student_model.train()\n teacher_model.eval() # Teacher model should be in eval mode\n\n # Initialize metrics dictionary\n metrics = {\n \"train_loss\": [],\n \"val_loss\": [],\n } # Add 'train_accuracy': [], 'val_accuracy': [] if tracking accuracy\n loss_fn = AdaptiveConfidenceDistillationLoss(temperature=2.0)\n best_val_loss = float(\"inf\")\n step = 0\n for epoch in range(num_epochs):\n # Training loop\n for inputs, labels in train_dataloader:\n if step % 200 == 0:\n # Validation loop\n val_loss = 0.0\n with torch.no_grad():\n for inputs, labels in val_dataloader:\n inputs, labels = inputs.to(device), labels.to(device)\n teacher_outputs = teacher_model(inputs)\n student_outputs = student_model(inputs)\n loss = loss_fn(student_outputs, teacher_outputs, labels)\n val_loss += loss.item() * inputs.size(\n 0\n ) # Inside the training loop\n metrics[\"train_loss\"].append(\n loss.item()\n ) # Assuming loss is your loss variable\n\n # Inside the validation loop\n metrics[\"val_loss\"].append(\n val_loss\n ) # Assuming val_loss is your accumulated validation loss\n step += 1\n print(f\"val_loss: {val_loss}\")\n # After training, plot and save metrics\n plot_and_save_metrics(metrics)\n inputs, labels = inputs.to(device), labels.to(device)\n optimizer.zero_grad()\n\n with torch.no_grad():\n teacher_outputs = teacher_model(inputs)\n\n student_outputs = student_model(inputs)\n\n loss = loss_fn(student_outputs, teacher_outputs, labels)\n loss.backward()\n optimizer.step()\n\n val_loss /= len(val_dataloader.dataset)\n print(f\"Epoch [{epoch+1}/{num_epochs}], Validation Loss: {val_loss:.4f}\")\n\n # Save the model checkpoint if validation loss improves\n if val_loss < best_val_loss:\n best_val_loss = val_loss\n torch.save(student_model.state_dict(), checkpoint_path)\n # After training, plot and save metrics\n plot_and_save_metrics(metrics)\n print(f\"Saving model checkpoint at {checkpoint_path}\")\n\n\n# Example usage\n# Assuming `train_dataloader`, `val_dataloader`, `optimizer`, and `device` are defined\ntrain_model_with_validation(\n student_model,\n teacher_model,\n train_dataloader,\n val_dataloader,\n optimizer,\n device,\n num_epochs=10,\n checkpoint_path=\"checkpoint.pth\",\n)","source_hash":"aec049768a636ee5c1da4badd75c577ef9b0a0665268f1006af96fee0e488a23","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:train.save_memory_bank","uri":"program://SuperAlignment/function/train.save_memory_bank#L39-L41","kind":"function","name":"save_memory_bank","path":"train.py","language":"python","start_line":39,"end_line":41,"context_start_line":19,"context_end_line":61,"code":"# We'll create random data with similar dimensions\nnum_samples = 1000\ninput_channels = 3\ninput_height = 32\ninput_width = 32\nnum_classes = 100\n\n# Define transformations\ntransform = transforms.Compose(\n [\n transforms.Resize((32, 32)),\n transforms.ToTensor(),\n ]\n)\n\n# Create an instance of the CustomImageDataset\nimage_dir = \"./images\" # Specify the correct path to your images\ndataset = CustomImageDataset(image_dir=image_dir, transform=transform)\n\n\ndef save_memory_bank(memory_bank, filename=\"label_memory_bank.json\"):\n with open(filename, \"w\") as file:\n json.dump(memory_bank, file)\n\n\n# After training is complete or when you're done using the dataset\nsave_memory_bank(dataset.memory_bank) # Save the updated memory bank to a file\n# Split dataset into train and validation sets\ntrain_size = int(0.8 * len(dataset))\nval_size = len(dataset) - train_size\ntrain_dataset, val_dataset = torch.utils.data.random_split(\n dataset, [train_size, val_size]\n)\n\n# Create DataLoaders\ntrain_dataloader = DataLoader(train_dataset, batch_size=32, shuffle=True)\nval_dataloader = DataLoader(val_dataset, batch_size=32, shuffle=False)\n\n# Define optimizer and device\noptimizer = optim.Adam(student_model.parameters(), lr=0.001)\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nprint(f\"Using device: {device}\")\n","source_hash":"aec049768a636ee5c1da4badd75c577ef9b0a0665268f1006af96fee0e488a23","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:train.load_image_paths_labels","uri":"program://SuperAlignment/function/train.load_image_paths_labels#L64-L69","kind":"function","name":"load_image_paths_labels","path":"train.py","language":"python","start_line":64,"end_line":69,"context_start_line":44,"context_end_line":89,"code":"# After training is complete or when you're done using the dataset\nsave_memory_bank(dataset.memory_bank) # Save the updated memory bank to a file\n# Split dataset into train and validation sets\ntrain_size = int(0.8 * len(dataset))\nval_size = len(dataset) - train_size\ntrain_dataset, val_dataset = torch.utils.data.random_split(\n dataset, [train_size, val_size]\n)\n\n# Create DataLoaders\ntrain_dataloader = DataLoader(train_dataset, batch_size=32, shuffle=True)\nval_dataloader = DataLoader(val_dataset, batch_size=32, shuffle=False)\n\n# Define optimizer and device\noptimizer = optim.Adam(student_model.parameters(), lr=0.001)\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nprint(f\"Using device: {device}\")\n\n\n# Step 1: Load Labels and Image Paths\ndef load_image_paths_labels(json_path):\n with open(json_path, \"r\") as f:\n data = json.load(f)\n image_paths = [os.path.join(\"./images\", item[\"image_path\"]) for item in data]\n labels = [item[\"caption\"] for item in data]\n return image_paths, labels\n\n\n# Example Training Loop Skeleton with Validation and Model Checkpointing\ndef train_model_with_validation(\n student_model,\n teacher_model,\n train_dataloader,\n val_dataloader,\n optimizer,\n device,\n num_epochs=10,\n checkpoint_path=\"checkpoint.pth\",\n):\n student_model.train()\n teacher_model.eval() # Teacher model should be in eval mode\n\n # Initialize metrics dictionary\n metrics = {\n \"train_loss\": [],\n \"val_loss\": [],","source_hash":"aec049768a636ee5c1da4badd75c577ef9b0a0665268f1006af96fee0e488a23","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:train.train_model_with_validation","uri":"program://SuperAlignment/function/train.train_model_with_validation#L73-L142","kind":"function","name":"train_model_with_validation","path":"train.py","language":"python","start_line":73,"end_line":142,"context_start_line":53,"context_end_line":156,"code":"# Create DataLoaders\ntrain_dataloader = DataLoader(train_dataset, batch_size=32, shuffle=True)\nval_dataloader = DataLoader(val_dataset, batch_size=32, shuffle=False)\n\n# Define optimizer and device\noptimizer = optim.Adam(student_model.parameters(), lr=0.001)\ndevice = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\nprint(f\"Using device: {device}\")\n\n\n# Step 1: Load Labels and Image Paths\ndef load_image_paths_labels(json_path):\n with open(json_path, \"r\") as f:\n data = json.load(f)\n image_paths = [os.path.join(\"./images\", item[\"image_path\"]) for item in data]\n labels = [item[\"caption\"] for item in data]\n return image_paths, labels\n\n\n# Example Training Loop Skeleton with Validation and Model Checkpointing\ndef train_model_with_validation(\n student_model,\n teacher_model,\n train_dataloader,\n val_dataloader,\n optimizer,\n device,\n num_epochs=10,\n checkpoint_path=\"checkpoint.pth\",\n):\n student_model.train()\n teacher_model.eval() # Teacher model should be in eval mode\n\n # Initialize metrics dictionary\n metrics = {\n \"train_loss\": [],\n \"val_loss\": [],\n } # Add 'train_accuracy': [], 'val_accuracy': [] if tracking accuracy\n loss_fn = AdaptiveConfidenceDistillationLoss(temperature=2.0)\n best_val_loss = float(\"inf\")\n step = 0\n for epoch in range(num_epochs):\n # Training loop\n for inputs, labels in train_dataloader:\n if step % 200 == 0:\n # Validation loop\n val_loss = 0.0\n with torch.no_grad():\n for inputs, labels in val_dataloader:\n inputs, labels = inputs.to(device), labels.to(device)\n teacher_outputs = teacher_model(inputs)\n student_outputs = student_model(inputs)\n loss = loss_fn(student_outputs, teacher_outputs, labels)\n val_loss += loss.item() * inputs.size(\n 0\n ) # Inside the training loop\n metrics[\"train_loss\"].append(\n loss.item()\n ) # Assuming loss is your loss variable\n\n # Inside the validation loop\n metrics[\"val_loss\"].append(\n val_loss\n ) # Assuming val_loss is your accumulated validation loss\n step += 1\n print(f\"val_loss: {val_loss}\")\n # After training, plot and save metrics\n plot_and_save_metrics(metrics)\n inputs, labels = inputs.to(device), labels.to(device)\n optimizer.zero_grad()\n\n with torch.no_grad():\n teacher_outputs = teacher_model(inputs)\n\n student_outputs = student_model(inputs)\n\n loss = loss_fn(student_outputs, teacher_outputs, labels)\n loss.backward()\n optimizer.step()\n\n val_loss /= len(val_dataloader.dataset)\n print(f\"Epoch [{epoch+1}/{num_epochs}], Validation Loss: {val_loss:.4f}\")\n\n # Save the model checkpoint if validation loss improves\n if val_loss < best_val_loss:\n best_val_loss = val_loss\n torch.save(student_model.state_dict(), checkpoint_path)\n # After training, plot and save metrics\n plot_and_save_metrics(metrics)\n print(f\"Saving model checkpoint at {checkpoint_path}\")\n\n\n# Example usage\n# Assuming `train_dataloader`, `val_dataloader`, `optimizer`, and `device` are defined\ntrain_model_with_validation(\n student_model,\n teacher_model,\n train_dataloader,\n val_dataloader,\n optimizer,\n device,\n num_epochs=10,\n checkpoint_path=\"checkpoint.pth\",\n)","source_hash":"aec049768a636ee5c1da4badd75c577ef9b0a0665268f1006af96fee0e488a23","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:utils","uri":"program://SuperAlignment/module/utils#L1-L34","kind":"module","name":"utils","path":"utils.py","language":"python","start_line":1,"end_line":34,"context_start_line":1,"context_end_line":34,"code":"import matplotlib.pyplot as plt\nimport json\n\n\ndef plot_and_save_metrics(\n metrics, filename=\"training_metrics.png\", metrics_path=\"training_metrics.json\"\n):\n epochs = range(1, len(metrics[\"train_loss\"]) + 1)\n\n plt.figure(figsize=(10, 5))\n plt.subplot(1, 2, 1)\n plt.plot(epochs, metrics[\"train_loss\"], label=\"Training Loss\")\n plt.plot(epochs, metrics[\"val_loss\"], label=\"Validation Loss\")\n plt.title(\"Loss Metrics\")\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Loss\")\n plt.legend()\n\n # If you track accuracy, you can plot it here similarly.\n # plt.subplot(1, 2, 2)\n # plt.plot(epochs, metrics['train_accuracy'], label='Training Accuracy')\n # plt.plot(epochs, metrics['val_accuracy'], label='Validation Accuracy')\n # plt.title('Accuracy Metrics')\n # plt.xlabel('Epoch')\n # plt.ylabel('Accuracy')\n # plt.legend()\n\n plt.tight_layout()\n plt.savefig(filename)\n plt.close()\n\n # Save metrics to a JSON file for further analysis\n with open(metrics_path, \"w\") as f:\n json.dump(metrics, f, indent=4)","source_hash":"7804c1866cae172702f44d671accd34ee657dc7840952f9d6700cc17f267e8bd","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:utils.plot_and_save_metrics","uri":"program://SuperAlignment/function/utils.plot_and_save_metrics#L5-L34","kind":"function","name":"plot_and_save_metrics","path":"utils.py","language":"python","start_line":5,"end_line":34,"context_start_line":1,"context_end_line":34,"code":"import matplotlib.pyplot as plt\nimport json\n\n\ndef plot_and_save_metrics(\n metrics, filename=\"training_metrics.png\", metrics_path=\"training_metrics.json\"\n):\n epochs = range(1, len(metrics[\"train_loss\"]) + 1)\n\n plt.figure(figsize=(10, 5))\n plt.subplot(1, 2, 1)\n plt.plot(epochs, metrics[\"train_loss\"], label=\"Training Loss\")\n plt.plot(epochs, metrics[\"val_loss\"], label=\"Validation Loss\")\n plt.title(\"Loss Metrics\")\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Loss\")\n plt.legend()\n\n # If you track accuracy, you can plot it here similarly.\n # plt.subplot(1, 2, 2)\n # plt.plot(epochs, metrics['train_accuracy'], label='Training Accuracy')\n # plt.plot(epochs, metrics['val_accuracy'], label='Validation Accuracy')\n # plt.title('Accuracy Metrics')\n # plt.xlabel('Epoch')\n # plt.ylabel('Accuracy')\n # plt.legend()\n\n plt.tight_layout()\n plt.savefig(filename)\n plt.close()\n\n # Save metrics to a JSON file for further analysis\n with open(metrics_path, \"w\") as f:\n json.dump(metrics, f, indent=4)","source_hash":"7804c1866cae172702f44d671accd34ee657dc7840952f9d6700cc17f267e8bd","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:generate_labels","uri":"program://SuperAlignment/module/generate_labels#L1-L78","kind":"module","name":"generate_labels","path":"generate_labels.py","language":"python","start_line":1,"end_line":78,"context_start_line":1,"context_end_line":78,"code":"import os\nfrom transformers import ViTImageProcessor, ViTForImageClassification\nfrom PIL import Image\nimport json\nimport torch\n\n\ndef generate_label_for_single_image(image_path):\n # Initialize the model and processor\n model = ViTForImageClassification.from_pretrained(\"google/vit-base-patch16-224\")\n feature_extractor = ViTImageProcessor.from_pretrained(\"google/vit-base-patch16-224\")\n\n # Load and process the image\n image = Image.open(image_path).convert(\"RGB\")\n inputs = feature_extractor(images=image, return_tensors=\"pt\")\n\n # Predict the class of the image\n with torch.no_grad():\n outputs = model(**inputs)\n\n logits = outputs.logits\n predicted_class_idx = logits.argmax(-1).item()\n\n # Optionally, print the predicted class (if id2label is available)\n predicted_label = (\n model.config.id2label[predicted_class_idx]\n if model.config.id2label\n else str(predicted_class_idx)\n )\n\n print(\"Predicted class index:\", predicted_class_idx)\n print(\"Predicted label:\", predicted_label)\n\n return predicted_class_idx, predicted_label\n\n\ndef generate_labels(image_dir, model_name, output_file, max_images=100):\n # Load the CLIP model and processor\n processor = ViTImageProcessor.from_pretrained(\"google/vit-base-patch16-224\")\n model = ViTForImageClassification.from_pretrained(\"google/vit-base-patch16-224\")\n\n # Fetch image paths\n images = os.listdir(image_dir)\n images = images[:max_images] # Limit to max_images\n\n labels = []\n\n for image_name in images:\n image_path = os.path.join(image_dir, image_name)\n\n # Load image\n image = Image.open(image_path).convert(\"RGB\")\n\n # Prepare the image for the model\n inputs = processor(images=image, return_tensors=\"pt\")\n\n # Generate image features (embeddings)\n with torch.no_grad():\n outputs = model(**inputs)\n\n # Here you would typically use the embeddings to find the closest text descriptions, but since\n # OpenCLIP doesn't provide direct label generation, we'll just save the embeddings for now.\n # This step is a placeholder for any specific label generation or nearest neighbor search you might implement.\n # For demonstration, let's assume a dummy label based on the max value index in the embeddings.\n logits = outputs.logits\n # model predicts one of the 1000 ImageNet classes\n predicted_class_idx = logits.argmax(-1).item()\n\n labels.append({\"image_path\": image_name, \"label\": predicted_class_idx})\n print(\"Predicted class: \", model.config.id2label[predicted_class_idx])\n # Save the labels to a JSON file\n with open(output_file, \"w\") as f:\n json.dump(labels, f, indent=4)\n\n\nimage_dir = \"./images\"\nmodel_name = \"google/vit-base-patch16-224\"\noutput_file = \"imagelabels.json\"","source_hash":"20a6fcb44164bd9974723b003b234785c2e029411323ddda3cb2fab53143ef64","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:generate_labels.generate_label_for_single_image","uri":"program://SuperAlignment/function/generate_labels.generate_label_for_single_image#L8-L34","kind":"function","name":"generate_label_for_single_image","path":"generate_labels.py","language":"python","start_line":8,"end_line":34,"context_start_line":1,"context_end_line":54,"code":"import os\nfrom transformers import ViTImageProcessor, ViTForImageClassification\nfrom PIL import Image\nimport json\nimport torch\n\n\ndef generate_label_for_single_image(image_path):\n # Initialize the model and processor\n model = ViTForImageClassification.from_pretrained(\"google/vit-base-patch16-224\")\n feature_extractor = ViTImageProcessor.from_pretrained(\"google/vit-base-patch16-224\")\n\n # Load and process the image\n image = Image.open(image_path).convert(\"RGB\")\n inputs = feature_extractor(images=image, return_tensors=\"pt\")\n\n # Predict the class of the image\n with torch.no_grad():\n outputs = model(**inputs)\n\n logits = outputs.logits\n predicted_class_idx = logits.argmax(-1).item()\n\n # Optionally, print the predicted class (if id2label is available)\n predicted_label = (\n model.config.id2label[predicted_class_idx]\n if model.config.id2label\n else str(predicted_class_idx)\n )\n\n print(\"Predicted class index:\", predicted_class_idx)\n print(\"Predicted label:\", predicted_label)\n\n return predicted_class_idx, predicted_label\n\n\ndef generate_labels(image_dir, model_name, output_file, max_images=100):\n # Load the CLIP model and processor\n processor = ViTImageProcessor.from_pretrained(\"google/vit-base-patch16-224\")\n model = ViTForImageClassification.from_pretrained(\"google/vit-base-patch16-224\")\n\n # Fetch image paths\n images = os.listdir(image_dir)\n images = images[:max_images] # Limit to max_images\n\n labels = []\n\n for image_name in images:\n image_path = os.path.join(image_dir, image_name)\n\n # Load image\n image = Image.open(image_path).convert(\"RGB\")\n\n # Prepare the image for the model","source_hash":"20a6fcb44164bd9974723b003b234785c2e029411323ddda3cb2fab53143ef64","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"py:generate_labels.generate_labels","uri":"program://SuperAlignment/function/generate_labels.generate_labels#L37-L73","kind":"function","name":"generate_labels","path":"generate_labels.py","language":"python","start_line":37,"end_line":73,"context_start_line":17,"context_end_line":78,"code":" # Predict the class of the image\n with torch.no_grad():\n outputs = model(**inputs)\n\n logits = outputs.logits\n predicted_class_idx = logits.argmax(-1).item()\n\n # Optionally, print the predicted class (if id2label is available)\n predicted_label = (\n model.config.id2label[predicted_class_idx]\n if model.config.id2label\n else str(predicted_class_idx)\n )\n\n print(\"Predicted class index:\", predicted_class_idx)\n print(\"Predicted label:\", predicted_label)\n\n return predicted_class_idx, predicted_label\n\n\ndef generate_labels(image_dir, model_name, output_file, max_images=100):\n # Load the CLIP model and processor\n processor = ViTImageProcessor.from_pretrained(\"google/vit-base-patch16-224\")\n model = ViTForImageClassification.from_pretrained(\"google/vit-base-patch16-224\")\n\n # Fetch image paths\n images = os.listdir(image_dir)\n images = images[:max_images] # Limit to max_images\n\n labels = []\n\n for image_name in images:\n image_path = os.path.join(image_dir, image_name)\n\n # Load image\n image = Image.open(image_path).convert(\"RGB\")\n\n # Prepare the image for the model\n inputs = processor(images=image, return_tensors=\"pt\")\n\n # Generate image features (embeddings)\n with torch.no_grad():\n outputs = model(**inputs)\n\n # Here you would typically use the embeddings to find the closest text descriptions, but since\n # OpenCLIP doesn't provide direct label generation, we'll just save the embeddings for now.\n # This step is a placeholder for any specific label generation or nearest neighbor search you might implement.\n # For demonstration, let's assume a dummy label based on the max value index in the embeddings.\n logits = outputs.logits\n # model predicts one of the 1000 ImageNet classes\n predicted_class_idx = logits.argmax(-1).item()\n\n labels.append({\"image_path\": image_name, \"label\": predicted_class_idx})\n print(\"Predicted class: \", model.config.id2label[predicted_class_idx])\n # Save the labels to a JSON file\n with open(output_file, \"w\") as f:\n json.dump(labels, f, indent=4)\n\n\nimage_dir = \"./images\"\nmodel_name = \"google/vit-base-patch16-224\"\noutput_file = \"imagelabels.json\"","source_hash":"20a6fcb44164bd9974723b003b234785c2e029411323ddda3cb2fab53143ef64","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"file:train_example.py","uri":"program://SuperAlignment/file/train_example.py","kind":"file","name":"train_example.py","path":"train_example.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import torch\nimport torch.nn as nn\nimport torch.nn.functional as F\nfrom torchvision.models import resnet18, resnet50 # Example models\n\n# Define the teacher (weak model) and student (strong model)\nteacher_model = resnet18(pretrained=True)\nstudent_model = resnet50(pretrained=True)\n\n\n# Custom Adaptive Confidence Distillation Loss\nclass AdaptiveConfidenceDistillationLoss(nn.Module):\n def __init__(self, temperature=1.0):\n super().__init__()\n self.temperature = temperature\n self.ce_loss = nn.CrossEntropyLoss()\n\n def forward(self, student_logits, teacher_logits, targets):\n # Soften probabilities\n soft_teacher_probs = F.softmax(teacher_logits / self.temperature, dim=1)\n soft_student_probs = F.log_softmax(student_logits / self.temperature, dim=1)","source_hash":"1d853ce261864b7b90ca11a013e5ff6feff4aa1e87a9d5d20878083564c9aba6","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"file:AdaptiveConfidenceDistillation.py","uri":"program://SuperAlignment/file/AdaptiveConfidenceDistillation.py","kind":"file","name":"AdaptiveConfidenceDistillation.py","path":"AdaptiveConfidenceDistillation.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import torch.nn as nn\nimport torch.nn.functional as F\n\n\n# Custom Adaptive Confidence Distillation Loss\nclass AdaptiveConfidenceDistillationLoss(nn.Module):\n def __init__(self, temperature=1.0):\n super().__init__()\n self.temperature = temperature\n self.ce_loss = nn.CrossEntropyLoss()\n\n def forward(self, student_logits, teacher_logits, targets):\n # Soften probabilities\n soft_teacher_probs = F.softmax(teacher_logits / self.temperature, dim=1)\n soft_student_probs = F.log_softmax(student_logits / self.temperature, dim=1)\n\n # Calculate the KL Divergence for the soft targets\n distillation_loss = F.kl_div(\n soft_student_probs, soft_teacher_probs, reduction=\"batchmean\"\n )\n","source_hash":"78f2354cb5ad0726bbf11cff4469be7a070132d3339921881ae5df2398b71f16","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"file:test_train_example.py","uri":"program://SuperAlignment/file/test_train_example.py","kind":"file","name":"test_train_example.py","path":"test_train_example.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import torch\nimport torch.nn as nn\nimport torch.optim as optim\nfrom torchvision.models import resnet18, resnet50\nfrom torch.utils.data import DataLoader, TensorDataset\nimport numpy as np\nfrom train_example import train_model\n\n# Define the teacher (weak model) and student (strong model)\nteacher_model = resnet18(pretrained=False) # Using pretrained=False for simplicity\nstudent_model = resnet50(pretrained=False)\n\n# Define a simple synthetic dataset resembling CIFAR-100\n# CIFAR-100 has 32x32 images with 3 channels\n# We'll create random data with similar dimensions\nnum_samples = 1000\ninput_channels = 3\ninput_height = 32\ninput_width = 32\nnum_classes = 100\n","source_hash":"6e808ad91b17c4e12df91f6ed188bfe810f9d6cb3ef55c61df0055a57b0abc0b","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"file:dataset.py","uri":"program://SuperAlignment/file/dataset.py","kind":"file","name":"dataset.py","path":"dataset.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import torch\nfrom torch.utils.data import Dataset\nimport os\nfrom PIL import Image\nfrom generate_labels import generate_label_for_single_image\nimport json\n\n\n# Custom Dataset Class\nclass CustomImageDataset(Dataset):\n def __init__(\n self, image_dir, transform=None, model_name=\"google/vit-base-patch16-224\"\n ):\n self.image_dir = image_dir\n self.transform = transform\n self.memory_bank = load_memory_bank() # Load existing labels from memory bank\n self.image_paths = [\n os.path.join(image_dir, img)\n for img in os.listdir(image_dir)\n if img.endswith((\".png\", \".jpg\", \".jpeg\"))\n ]","source_hash":"981d68dd2e2858f57d74c1cd302ee09901a2fa38c665753fa9e6a5a0b08f1267","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"file:train.py","uri":"program://SuperAlignment/file/train.py","kind":"file","name":"train.py","path":"train.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import torch\nimport torch.optim as optim\nfrom torchvision import transforms\nfrom torchvision.models import resnet18, resnet50\nfrom torch.utils.data import DataLoader\nimport numpy as np\nimport os\nimport json\nfrom utils import plot_and_save_metrics\nfrom dataset import CustomImageDataset\nfrom AdaptiveConfidenceDistillation import AdaptiveConfidenceDistillationLoss\n\n# Define the teacher (weak model) and student (strong model)\nteacher_model = resnet18(pretrained=True) # Using pretrained=False for simplicity\nstudent_model = resnet50(pretrained=True)\n\n# Define a simple synthetic dataset resembling CIFAR-100\n# CIFAR-100 has 32x32 images with 3 channels\n# We'll create random data with similar dimensions\nnum_samples = 1000\ninput_channels = 3","source_hash":"aec049768a636ee5c1da4badd75c577ef9b0a0665268f1006af96fee0e488a23","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"file:utils.py","uri":"program://SuperAlignment/file/utils.py","kind":"file","name":"utils.py","path":"utils.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import matplotlib.pyplot as plt\nimport json\n\n\ndef plot_and_save_metrics(\n metrics, filename=\"training_metrics.png\", metrics_path=\"training_metrics.json\"\n):\n epochs = range(1, len(metrics[\"train_loss\"]) + 1)\n\n plt.figure(figsize=(10, 5))\n plt.subplot(1, 2, 1)\n plt.plot(epochs, metrics[\"train_loss\"], label=\"Training Loss\")\n plt.plot(epochs, metrics[\"val_loss\"], label=\"Validation Loss\")\n plt.title(\"Loss Metrics\")\n plt.xlabel(\"Epoch\")\n plt.ylabel(\"Loss\")\n plt.legend()\n\n # If you track accuracy, you can plot it here similarly.\n # plt.subplot(1, 2, 2)\n # plt.plot(epochs, metrics['train_accuracy'], label='Training Accuracy')","source_hash":"7804c1866cae172702f44d671accd34ee657dc7840952f9d6700cc17f267e8bd","truncated":false}
{"repo_id":"SuperAlignment","entity_id":"file:generate_labels.py","uri":"program://SuperAlignment/file/generate_labels.py","kind":"file","name":"generate_labels.py","path":"generate_labels.py","language":"python","start_line":1,"end_line":1,"context_start_line":1,"context_end_line":21,"code":"import os\nfrom transformers import ViTImageProcessor, ViTForImageClassification\nfrom PIL import Image\nimport json\nimport torch\n\n\ndef generate_label_for_single_image(image_path):\n # Initialize the model and processor\n model = ViTForImageClassification.from_pretrained(\"google/vit-base-patch16-224\")\n feature_extractor = ViTImageProcessor.from_pretrained(\"google/vit-base-patch16-224\")\n\n # Load and process the image\n image = Image.open(image_path).convert(\"RGB\")\n inputs = feature_extractor(images=image, return_tensors=\"pt\")\n\n # Predict the class of the image\n with torch.no_grad():\n outputs = model(**inputs)\n\n logits = outputs.logits","source_hash":"20a6fcb44164bd9974723b003b234785c2e029411323ddda3cb2fab53143ef64","truncated":false}
|