id int64 0 190k | prompt stringlengths 21 13.4M | docstring stringlengths 1 12k ⌀ |
|---|---|---|
33,627 | import torch
import torch.nn as nn
class block(nn.Module):
def __init__(
self, in_channels, intermediate_channels, identity_downsample=None, stride=1
):
super().__init__()
self.expansion = 4
self.conv1 = nn.Conv2d(
in_channels,
intermediate_channels,
... | null |
33,628 | import torch
import torch.nn as nn
class block(nn.Module):
def __init__(
self, in_channels, intermediate_channels, identity_downsample=None, stride=1
):
super().__init__()
self.expansion = 4
self.conv1 = nn.Conv2d(
in_channels,
intermediate_channels,
... | null |
33,629 | import torch
import torch.nn as nn
class block(nn.Module):
def __init__(
self, in_channels, intermediate_channels, identity_downsample=None, stride=1
):
def forward(self, x):
class ResNet(nn.Module):
def __init__(self, block, layers, image_channels, num_classes):
def forward(self... | null |
33,630 | import torch
from dataset import HorseZebraDataset
import sys
from utils import save_checkpoint, load_checkpoint
from torch.utils.data import DataLoader
import torch.nn as nn
import torch.optim as optim
import config
from tqdm import tqdm
from torchvision.utils import save_image
from discriminator_model import Discrimi... | null |
33,631 | import random, torch, os, numpy as np
import torch.nn as nn
import config
import copy
def save_checkpoint(model, optimizer, filename="my_checkpoint.pth.tar"):
print("=> Saving checkpoint")
checkpoint = {
"state_dict": model.state_dict(),
"optimizer": optimizer.state_dict(),
}
torch.save... | null |
33,632 | import random, torch, os, numpy as np
import torch.nn as nn
import config
import copy
def load_checkpoint(checkpoint_file, model, optimizer, lr):
print("=> Loading checkpoint")
checkpoint = torch.load(checkpoint_file, map_location=config.DEVICE)
model.load_state_dict(checkpoint["state_dict"])
optimizer... | null |
33,633 | import random, torch, os, numpy as np
import torch.nn as nn
import config
import copy
def seed_everything(seed=42):
os.environ["PYTHONHASHSEED"] = str(seed)
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.bac... | null |
33,634 | import torch
from utils import save_checkpoint, load_checkpoint, save_some_examples
import torch.nn as nn
import torch.optim as optim
import config
from dataset import MapDataset
from generator_model import Generator
from discriminator_model import Discriminator
from torch.utils.data import DataLoader
from tqdm import ... | null |
33,635 | import torch
import config
from torchvision.utils import save_image
def save_some_examples(gen, val_loader, epoch, folder):
x, y = next(iter(val_loader))
x, y = x.to(config.DEVICE), y.to(config.DEVICE)
gen.eval()
with torch.no_grad():
y_fake = gen(x)
y_fake = y_fake * 0.5 + 0.5 # remov... | null |
33,636 | import torch
import config
from torchvision.utils import save_image
def save_checkpoint(model, optimizer, filename="my_checkpoint.pth.tar"):
print("=> Saving checkpoint")
checkpoint = {
"state_dict": model.state_dict(),
"optimizer": optimizer.state_dict(),
}
torch.save(checkpoint, filen... | null |
33,637 | import torch
import config
from torchvision.utils import save_image
def load_checkpoint(checkpoint_file, model, optimizer, lr):
print("=> Loading checkpoint")
checkpoint = torch.load(checkpoint_file, map_location=config.DEVICE)
model.load_state_dict(checkpoint["state_dict"])
optimizer.load_state_dict(c... | null |
33,638 | import torch
import config
from torch import nn
from torch import optim
from utils import load_checkpoint, save_checkpoint, plot_examples
from loss import VGGLoss
from torch.utils.data import DataLoader
from model import Generator, Discriminator
from tqdm import tqdm
from dataset import MyImageFolder
torch.backends.cud... | null |
33,639 | import torch
import os
import config
import numpy as np
from PIL import Image
from torchvision.utils import save_image
def save_checkpoint(model, optimizer, filename="my_checkpoint.pth.tar"):
print("=> Saving checkpoint")
checkpoint = {
"state_dict": model.state_dict(),
"optimizer": optimizer.s... | null |
33,640 | import torch
import os
import config
import numpy as np
from PIL import Image
from torchvision.utils import save_image
def load_checkpoint(checkpoint_file, model, optimizer, lr):
print("=> Loading checkpoint")
checkpoint = torch.load(checkpoint_file, map_location=config.DEVICE)
model.load_state_dict(checkp... | null |
33,641 | import torch
import config
from torch import nn
from torch import optim
from utils import gradient_penalty, load_checkpoint, save_checkpoint, plot_examples
from loss import VGGLoss
from torch.utils.data import DataLoader
from model import Generator, Discriminator, initialize_weights
from tqdm import tqdm
from dataset i... | null |
33,642 | import torch
import os
import config
import numpy as np
from PIL import Image
from torchvision.utils import save_image
def gradient_penalty(critic, real, fake, device):
BATCH_SIZE, C, H, W = real.shape
alpha = torch.rand((BATCH_SIZE, 1, 1, 1)).repeat(1, C, H, W).to(device)
interpolated_images = real * alph... | null |
33,644 | import torch
import os
import config
import numpy as np
from PIL import Image
from torchvision.utils import save_image
def load_checkpoint(checkpoint_file, model, optimizer, lr):
print("=> Loading checkpoint")
checkpoint = torch.load(checkpoint_file, map_location=config.DEVICE)
# model.load_state_dict(chec... | null |
33,645 | import torch
import os
import config
import numpy as np
from PIL import Image
from torchvision.utils import save_image
def plot_examples(low_res_folder, gen):
files = os.listdir(low_res_folder)
gen.eval()
for file in files:
image = Image.open("test_images/" + file)
with torch.no_grad():
... | null |
33,646 | import torch
from torch import nn
def initialize_weights(model, scale=0.1):
for m in model.modules():
if isinstance(m, nn.Conv2d):
nn.init.kaiming_normal_(m.weight.data)
m.weight.data *= scale
elif isinstance(m, nn.Linear):
nn.init.kaiming_normal_(m.weight.data)... | null |
33,647 | import torch
import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from utils import (
gradient_penalty,
plot_to_tensorboard,
save_checkpoint,
load_checkpoi... | null |
33,648 | import torch
import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from utils import (
gradient_penalty,
plot_to_tensorboard,
save_checkpoint,
load_checkpoi... | null |
33,649 | import torch
import random
import numpy as np
import os
import torchvision
import torch.nn as nn
import config
from torchvision.utils import save_image
from scipy.stats import truncnorm
def save_checkpoint(model, optimizer, filename="my_checkpoint.pth.tar"):
print("=> Saving checkpoint")
checkpoint = {
... | null |
33,650 | import torch
import random
import numpy as np
import os
import torchvision
import torch.nn as nn
import config
from torchvision.utils import save_image
from scipy.stats import truncnorm
def load_checkpoint(checkpoint_file, model, optimizer, lr):
print("=> Loading checkpoint")
checkpoint = torch.load(checkpoint... | null |
33,651 | import torch
import random
import numpy as np
import os
import torchvision
import torch.nn as nn
import config
from torchvision.utils import save_image
from scipy.stats import truncnorm
def seed_everything(seed=42):
os.environ['PYTHONHASHSEED'] = str(seed)
random.seed(seed)
np.random.seed(seed)
torch.m... | null |
33,652 | import torch
import random
import numpy as np
import os
import torchvision
import torch.nn as nn
import config
from torchvision.utils import save_image
from scipy.stats import truncnorm
The provided code snippet includes necessary dependencies for implementing the `generate_examples` function. Write a Python function ... | Tried using truncation trick here but not sure it actually helped anything, you can remove it if you like and just sample from torch.randn |
33,653 | import torch
import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from utils import (
gradient_penalty,
plot_to_tensorboard,
save_checkpoint,
load_checkpoi... | null |
33,654 | import torch
import torch.optim as optim
import torchvision.datasets as datasets
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
from torch.utils.tensorboard import SummaryWriter
from utils import (
gradient_penalty,
plot_to_tensorboard,
save_checkpoint,
load_checkpoi... | null |
33,655 | import torch
import random
import numpy as np
import os
import torchvision
import torch.nn as nn
import warnings
def save_checkpoint(model, optimizer, filename="my_checkpoint.pth.tar"):
print("=> Saving checkpoint")
checkpoint = {
"state_dict": model.state_dict(),
"optimizer": optimizer.state_d... | null |
33,656 | import torch
import random
import numpy as np
import os
import torchvision
import torch.nn as nn
import warnings
def load_checkpoint(checkpoint_file, model, optimizer, lr):
print("=> Loading checkpoint")
checkpoint = torch.load(checkpoint_file, map_location="cuda")
model.load_state_dict(checkpoint["state_d... | null |
33,657 | import torch
import random
import numpy as np
import os
import torchvision
import torch.nn as nn
import warnings
def seed_everything(seed=42):
os.environ['PYTHONHASHSEED'] = str(seed)
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_s... | null |
33,658 | from PIL import Image
from tqdm import tqdm
import os
from multiprocessing import Pool
root_dir = "FFHQ/images1024x1024/"
def resize(file, size, folder_to_save):
image = Image.open(root_dir + file).resize((size, size), Image.LANCZOS)
image.save(folder_to_save+file, quality=100) | null |
33,659 | import torch
import spacy
from torchtext.data.metrics import bleu_score
import sys
def translate_sentence(model, sentence, german, english, device, max_length=50):
# Load german tokenizer
spacy_ger = spacy.load("de")
# Create tokens using spacy and everything in lower case (which is what our vocab is)
i... | null |
33,660 | import torch
import spacy
from torchtext.data.metrics import bleu_score
import sys
def save_checkpoint(state, filename="my_checkpoint.pth.tar"):
print("=> Saving checkpoint")
torch.save(state, filename) | null |
33,661 | import torch
import spacy
from torchtext.data.metrics import bleu_score
import sys
def load_checkpoint(checkpoint, model, optimizer):
print("=> Loading checkpoint")
model.load_state_dict(checkpoint["state_dict"])
optimizer.load_state_dict(checkpoint["optimizer"]) | null |
33,662 | import random
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import spacy
from utils import translate_sentence, bleu, save_checkpoint, load_checkpoint
from torch.utils.tensorboard import SummaryWriter
from torchtext.datasets import Multi30k
from torchtext.data import Field, BucketIte... | null |
33,663 | import random
import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np
import spacy
from utils import translate_sentence, bleu, save_checkpoint, load_checkpoint
from torch.utils.tensorboard import SummaryWriter
from torchtext.datasets import Multi30k
from torchtext.data import Field, BucketIte... | null |
33,664 | import torch
import spacy
from torchtext.data.metrics import bleu_score
import sys
def translate_sentence(model, sentence, german, english, device, max_length=50):
# Load german tokenizer
spacy_ger = spacy.load("de")
# Create tokens using spacy and everything in lower case (which is what our vocab is)
i... | null |
33,667 | import torch
import torch.nn as nn
import torch.optim as optim
import spacy
from utils import translate_sentence, bleu, save_checkpoint, load_checkpoint
from torch.utils.tensorboard import SummaryWriter
from torchtext.datasets import Multi30k
from torchtext.data import Field, BucketIterator
spacy_ger = spacy.load("de")... | null |
33,668 | import torch
import torch.nn as nn
import torch.optim as optim
import spacy
from utils import translate_sentence, bleu, save_checkpoint, load_checkpoint
from torch.utils.tensorboard import SummaryWriter
from torchtext.datasets import Multi30k
from torchtext.data import Field, BucketIterator
spacy_eng = spacy.load("en")... | null |
33,669 | import torch
import spacy
from torchtext.data.metrics import bleu_score
import sys
def translate_sentence(model, sentence, german, english, device, max_length=50):
def bleu(data, model, german, english, device):
targets = []
outputs = []
for example in data:
src = vars(example)["src"]
trg ... | null |
33,672 | import torch
import torch.nn as nn
import torch.optim as optim
from torchtext.datasets import Multi30k
from torchtext.data import Field, BucketIterator
import numpy as np
import spacy
import random
from torch.utils.tensorboard import SummaryWriter
from utils import translate_sentence, bleu, save_checkpoint, load_check... | null |
33,673 | import torch
import torch.nn as nn
import torch.optim as optim
from torchtext.datasets import Multi30k
from torchtext.data import Field, BucketIterator
import numpy as np
import spacy
import random
from torch.utils.tensorboard import SummaryWriter
from utils import translate_sentence, bleu, save_checkpoint, load_check... | null |
33,674 | import evaluate
from transformers import Seq2SeqTrainer
from transformers import WhisperForConditionalGeneration
import torch
from dataclasses import dataclass
from typing import Any, Dict, List, Union
from transformers import WhisperProcessor, WhisperTokenizer, WhisperFeatureExtractor
from datasets import load_dataset... | null |
33,675 | import evaluate
from transformers import Seq2SeqTrainer
from transformers import WhisperForConditionalGeneration
import torch
from dataclasses import dataclass
from typing import Any, Dict, List, Union
from transformers import WhisperProcessor, WhisperTokenizer, WhisperFeatureExtractor
from datasets import load_dataset... | null |
33,676 | import torch
import torch.nn as nn
import torch.optim as optim
from PIL import Image
import torchvision.transforms as transforms
import torchvision.models as models
from torchvision.utils import save_image
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
loader = transforms.Compose(
[
t... | null |
33,677 | import spacy
from torchtext.datasets import Multi30k
from torchtext.data import Field, BucketIterator
spacy_eng = spacy.load("en")
def tokenize_eng(text):
return [tok.text for tok in spacy_eng.tokenizer(text)] | null |
33,678 | import spacy
from torchtext.datasets import Multi30k
from torchtext.data import Field, BucketIterator
spacy_ger = spacy.load("de")
def tokenize_ger(text):
return [tok.text for tok in spacy_ger.tokenizer(text)] | null |
33,679 | import torch
import torch.nn as nn
import torch.optim as optim
import spacy
from torchtext.data import Field, TabularDataset, BucketIterator
spacy_en = spacy.load("en")
def tokenize(text):
return [tok.text for tok in spacy_en.tokenizer(text)] | null |
33,680 | import spacy
import pandas as pd
from torchtext.data import Field, BucketIterator, TabularDataset
from sklearn.model_selection import train_test_split
spacy_eng = spacy.load("en")
def tokenize_eng(text):
return [tok.text for tok in spacy_eng.tokenizer(text)] | null |
33,681 | import spacy
import pandas as pd
from torchtext.data import Field, BucketIterator, TabularDataset
from sklearn.model_selection import train_test_split
spacy_ger = spacy.load("de")
def tokenize_ger(text):
return [tok.text for tok in spacy_ger.tokenizer(text)] | null |
33,682 | import torch
import torchvision.datasets as datasets
from tqdm import tqdm
from torch import nn, optim
from model import VariationalAutoEncoder
from torchvision import transforms
from torchvision.utils import save_image
from torch.utils.data import DataLoader
dataset = datasets.MNIST(root="dataset/", train=True, trans... | Generates (num_examples) of a particular digit. Specifically we extract an example of each digit, then after we have the mu, sigma representation for each digit we can sample from that. After we sample we can run the decoder part of the VAE and generate examples. |
33,683 | import torch
import torch.nn as nn
import torch.nn.functional as F
from torchvision.utils import save_image
The provided code snippet includes necessary dependencies for implementing the `inference` function. Write a Python function `def inference(model, dataset, digit, num_examples=1)` to solve the following problem... | Generates (num_examples) of a particular digit. Specifically we extract an example of each digit, then after we have the mu, sigma representation for each digit we can sample from that. After we sample we can run the decoder part of the VAE and generate examples. |
33,684 | import torch
from tqdm import tqdm
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
from torch.utils.tensorboard import SummaryWriter
from utils import save_checkpoint, load_checkpoint, print_examples
from get_loader import get_loader
from model import CNNtoRNN
def save_che... | null |
33,685 | import torch
import torchvision.transforms as transforms
from PIL import Image
def print_examples(model, device, dataset):
transform = transforms.Compose(
[
transforms.Resize((299, 299)),
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5)),
... | null |
33,686 | from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorWithPadding
from transformers import Trainer
tokenizer = AutoTokenizer.from_pretrained(checkpoint)
from transformers import TrainingArguments
from transformers import AutoModelForSequenceClassification
def tokenize_function(example):... | null |
33,687 | from datasets import load_dataset
from transformers import AutoTokenizer, DataCollatorWithPadding
from transformers import Trainer
from transformers import TrainingArguments
from transformers import AutoModelForSequenceClassification
def compute_metrics(eval_preds):
metric = evaluate.load("glue", "mrpc")
logit... | null |
33,688 | import config
import torch
import torch.optim as optim
from model import YOLOv3
from tqdm import tqdm
from utils import (
mean_average_precision,
cells_to_bboxes,
get_evaluation_bboxes,
save_checkpoint,
load_checkpoint,
check_class_accuracy,
get_loaders,
plot_couple_examples
)
from loss ... | null |
33,689 | import config
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
import os
import random
import torch
from collections import Counter
from torch.utils.data import DataLoader
from tqdm import tqdm
The provided code snippet includes necessary dependencies for implementing the `iou_wi... | Parameters: boxes1 (tensor): width and height of the first bounding boxes boxes2 (tensor): width and height of the second bounding boxes Returns: tensor: Intersection over union of the corresponding boxes |
33,690 | import config
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
import os
import random
import torch
from collections import Counter
from torch.utils.data import DataLoader
from tqdm import tqdm
def intersection_over_union(boxes_preds, boxes_labels, box_format="midpoint"):
"""
... | Video explanation of this function: https://youtu.be/FppOzcDvaDI This function calculates mean average precision (mAP) Parameters: pred_boxes (list): list of lists containing all bboxes with each bboxes specified as [train_idx, class_prediction, prob_score, x1, y1, x2, y2] true_boxes (list): Similar as pred_boxes excep... |
33,691 | import config
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
import os
import random
import torch
from collections import Counter
from torch.utils.data import DataLoader
from tqdm import tqdm
def non_max_suppression(bboxes, iou_threshold, threshold, box_format="corners"):
""... | null |
33,692 | import config
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
import os
import random
import torch
from collections import Counter
from torch.utils.data import DataLoader
from tqdm import tqdm
def check_class_accuracy(model, loader, threshold):
model.eval()
tot_class_pre... | null |
33,693 | import config
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
import os
import random
import torch
from collections import Counter
from torch.utils.data import DataLoader
from tqdm import tqdm
def get_mean_std(loader):
# var[X] = E[X**2] - E[X]**2
channels_sum, channels_... | null |
33,694 | import config
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
import os
import random
import torch
from collections import Counter
from torch.utils.data import DataLoader
from tqdm import tqdm
def save_checkpoint(model, optimizer, filename="my_checkpoint.pth.tar"):
print("=>... | null |
33,695 | import config
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
import os
import random
import torch
from collections import Counter
from torch.utils.data import DataLoader
from tqdm import tqdm
def load_checkpoint(checkpoint_file, model, optimizer, lr):
print("=> Loading chec... | null |
33,696 | import config
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
import os
import random
import torch
from collections import Counter
from torch.utils.data import DataLoader
from tqdm import tqdm
class YOLODataset(Dataset):
def __init__(
self,
csv_file,
... | null |
33,697 | import config
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
import os
import random
import torch
from collections import Counter
from torch.utils.data import DataLoader
from tqdm import tqdm
def non_max_suppression(bboxes, iou_threshold, threshold, box_format="corners"):
""... | null |
33,698 | import config
import matplotlib.pyplot as plt
import matplotlib.patches as patches
import numpy as np
import os
import random
import torch
from collections import Counter
from torch.utils.data import DataLoader
from tqdm import tqdm
def seed_everything(seed=42):
os.environ['PYTHONHASHSEED'] = str(seed)
random.... | null |
33,699 | import torch
import torchvision.transforms as transforms
import torch.optim as optim
import torchvision.transforms.functional as FT
from tqdm import tqdm
from torch.utils.data import DataLoader
from model import Yolov1
from dataset import VOCDataset
from utils import (
non_max_suppression,
mean_average_precisio... | null |
33,700 | import torch
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches
from collections import Counter
def intersection_over_union(boxes_preds, boxes_labels, box_format="midpoint"):
"""
Calculates intersection over union
Parameters:
boxes_preds (tensor): Predictions of ... | Calculates mean average precision Parameters: pred_boxes (list): list of lists containing all bboxes with each bboxes specified as [train_idx, class_prediction, prob_score, x1, y1, x2, y2] true_boxes (list): Similar as pred_boxes except all the correct ones iou_threshold (float): threshold where predicted bboxes is cor... |
33,701 | import torch
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches
from collections import Counter
The provided code snippet includes necessary dependencies for implementing the `plot_image` function. Write a Python function `def plot_image(image, boxes)` to solve the following proble... | Plots predicted bounding boxes on the image |
33,702 | import torch
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches
from collections import Counter
def non_max_suppression(bboxes, iou_threshold, threshold, box_format="corners"):
def cellboxes_to_boxes(out, S=7):
def get_bboxes(
loader,
model,
iou_threshold,
threshold... | null |
33,703 | import torch
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches
from collections import Counter
def save_checkpoint(state, filename="my_checkpoint.pth.tar"):
print("=> Saving checkpoint")
torch.save(state, filename) | null |
33,704 | import torch
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.patches as patches
from collections import Counter
def load_checkpoint(checkpoint, model, optimizer):
print("=> Loading checkpoint")
model.load_state_dict(checkpoint["state_dict"])
optimizer.load_state_dict(checkpoint["optimi... | null |
33,705 | import torch
from collections import Counter
from iou import intersection_over_union
def intersection_over_union(boxes_preds, boxes_labels, box_format="midpoint"):
"""
Calculates intersection over union
Parameters:
boxes_preds (tensor): Predictions of Bounding Boxes (BATCH_SIZE, 4)
boxes_l... | Calculates mean average precision Parameters: pred_boxes (list): list of lists containing all bboxes with each bboxes specified as [train_idx, class_prediction, prob_score, x1, y1, x2, y2] true_boxes (list): Similar as pred_boxes except all the correct ones iou_threshold (float): threshold where predicted bboxes is cor... |
33,706 | import torch
from iou import intersection_over_union
def intersection_over_union(boxes_preds, boxes_labels, box_format="midpoint"):
"""
Calculates intersection over union
Parameters:
boxes_preds (tensor): Predictions of Bounding Boxes (BATCH_SIZE, 4)
boxes_labels (tensor): Correct Labels o... | Does Non Max Suppression given bboxes Parameters: bboxes (list): list of lists containing all bboxes with each bboxes specified as [class_pred, prob_score, x1, y1, x2, y2] iou_threshold (float): threshold where predicted bboxes is correct threshold (float): threshold to remove predicted bboxes (independent of IoU) box_... |
33,707 | import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import DataLoader
from tqdm import tqdm
from model import Net
from utils import check_accuracy, load_checkpoint, save_checkpoint, make_prediction
import config
from dataset import MyImageFolder
def train_fn(loader, model, optimizer, l... | null |
33,708 | import torch
import torch.nn.functional as F
import os
from PIL import Image
import pandas as pd
import numpy as np
from tqdm import tqdm
def check_accuracy(loader, model, device="cuda"):
num_correct = 0
num_samples = 0
model.eval()
with torch.no_grad():
for x, y in loader:
x = x.t... | null |
33,709 | import torch
import torch.nn.functional as F
import os
from PIL import Image
import pandas as pd
import numpy as np
from tqdm import tqdm
def save_checkpoint(state, filename="my_checkpoint.pth.tar"):
print("=> Saving checkpoint")
torch.save(state, filename) | null |
33,710 | import torch
import torch.nn.functional as F
import os
from PIL import Image
import pandas as pd
import numpy as np
from tqdm import tqdm
def load_checkpoint(checkpoint, model, optimizer):
print("=> Loading checkpoint")
model.load_state_dict(checkpoint['state_dict'])
optimizer.load_state_dict(checkpoint['o... | null |
33,711 | import torch
import torch.nn.functional as F
import os
from PIL import Image
import pandas as pd
import numpy as np
from tqdm import tqdm
def make_prediction(model, transform, rootdir, device):
files = os.listdir(rootdir)
preds = []
model.eval()
files = sorted(files, key=lambda x: float(x.split(".")[0... | null |
33,715 | import random
import PIL, PIL.ImageOps, PIL.ImageEnhance, PIL.ImageDraw
import numpy as np
import torch
from PIL import Image
def CutoutAbs(img, v): # [0, 60] => percentage: [0, 0.2]
# assert 0 <= v <= 20
if v < 0:
return img
w, h = img.size
x0 = np.random.uniform(w)
y0 = np.random.uniform(... | null |
33,718 | import random
import PIL, PIL.ImageOps, PIL.ImageEnhance, PIL.ImageDraw
import numpy as np
import torch
from PIL import Image
def ShearX(img, v):
def ShearY(img, v):
def TranslateXabs(img, v):
def TranslateYabs(img, v):
def Rotate(img, v):
def AutoContrast(img, _):
def Invert(img, _):
def Equalize(img, _):
def Solarize... | null |
33,719 | import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import (
DataLoader,
)
import torchvision.datasets as datasets
import torchvision.transforms as transforms
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
def check_accur... | null |
33,720 | import torch
import torch.nn as nn
import torch.optim as optim
from torch.utils.data import (
DataLoader,
)
import torchvision.datasets as datasets
import torchvision.transforms as transforms
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
def check_accuracy(loader, model):
num_corre... | null |
33,721 | import torch
import torchvision
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import (
DataLoader,
)
import torchvision.datasets as datasets
import torchvision.transforms as transforms
def save_checkpoint(state, filename="my_checkpoint.pth.tar"):
p... | null |
33,722 | import torch
import torchvision
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import (
DataLoader,
)
import torchvision.datasets as datasets
import torchvision.transforms as transforms
def load_checkpoint(checkpoint, model, optimizer):
print("=> Lo... | null |
33,723 | import os
import pandas as pd
import spacy
import torch
from torch.nn.utils.rnn import pad_sequence
from torch.utils.data import DataLoader, Dataset
from PIL import Image
import torchvision.transforms as transforms
class FlickrDataset(Dataset):
def __init__(self, root_dir, captions_file, transform=None, freq_t... | null |
33,724 | import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import (
DataLoader,
)
import torchvision.datasets as datasets
import torchvision.transforms as transforms
from tqdm import tqdm
device = "cuda" if torch.cuda.is_available() else "cpu"
def ch... | null |
33,725 | import random
import torch
import os
import numpy as np
def seed_everything(seed=42):
os.environ["PYTHONHASHSEED"] = str(seed)
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
torch.backends.cudnn.deterministic = Tr... | null |
33,726 | import torch
import torch.nn.functional as F
import torchvision.datasets as datasets
import torchvision.transforms as transforms
from torch import optim
from torch import nn
from torch.utils.data import (
DataLoader,
)
from tqdm import tqdm
device = torch.device("cuda" if torch.cuda.is_available() else "cpu"... | Check accuracy of our trained model given a loader and a model Parameters: loader: torch.utils.data.DataLoader A loader for the dataset you want to check accuracy on model: nn.Module The model you want to check accuracy on Returns: acc: float The accuracy of the model on the dataset given by the loader |
33,727 | import torch
import torchvision.datasets as datasets
import os
from torch.utils.data import WeightedRandomSampler, DataLoader
import torchvision.transforms as transforms
import torch.nn as nn
def get_loader(root_dir, batch_size):
my_transforms = transforms.Compose(
[
transforms.Resize((224, 224... | null |
33,728 | import torch
import torch.nn.functional as F
import torchvision.datasets as datasets
import torchvision.transforms as transforms
from torch import optim
from torch import nn
from torch.utils.data import (
DataLoader,
)
from tqdm import tqdm
device = torch.device("cuda" if torch.cuda.is_available() else "cpu"... | null |
33,729 | import torch
import torchvision.transforms as transforms
from torch.utils.data import DataLoader
import torchvision.datasets as datasets
from tqdm import tqdm
mean, std = get_mean_std(train_loader)
def get_mean_std(loader):
# var[X] = E[X**2] - E[X]**2
channels_sum, channels_sqrd_sum, num_batches = 0, 0, 0
... | null |
33,730 | import torch
import torch.nn as nn
import torch.optim as optim
import torchvision.transforms as transforms
import torchvision
import os
import pandas as pd
from PIL import Image
from torch.utils.data import (
Dataset,
DataLoader,
)
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
print(... | null |
33,731 | import random
import cv2
from matplotlib import pyplot as plt
import matplotlib.patches as patches
import numpy as np
import albumentations as A
def visualize(image):
plt.figure(figsize=(10, 10))
plt.axis("off")
plt.imshow(image)
plt.show() | null |
33,732 | import random
import cv2
from matplotlib import pyplot as plt
import matplotlib.patches as patches
import numpy as np
import albumentations as A
def visualize_bbox(img, bbox, class_name, color=(255, 0, 0), thickness=5):
"""Visualizes a single bounding box on the image"""
x_min, y_min, x_max, y_max = map(int, bb... | null |
33,733 | import torch
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import (
DataLoader,
)
import torchvision.datasets as datasets
import torchvision.transforms as transforms
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
assert device ==... | null |
33,734 | import torch
import torch.nn.functional as F
import torchvision.datasets as datasets
import torchvision.transforms as transforms
from torch import optim
from torch import nn
from torch.utils.data import (
DataLoader,
)
from tqdm import tqdm
device = "cuda" if torch.cuda.is_available() else "cpu"
def check_a... | null |
33,735 | import torch
import torchvision
import torch.nn as nn
import torch.optim as optim
import torch.nn.functional as F
from torch.utils.data import (
DataLoader,
)
import torchvision.datasets as datasets
import torchvision.transforms as transforms
from tqdm import tqdm
device = torch.device("cuda" if torch.cuda.is... | null |
33,736 | import numpy as np
from scipy.integrate import simpson
import matplotlib.pyplot as plt
import warnings
def true_positives(y_true, y_pred):
tp = 0
for label, pred in zip(y_true, y_pred):
if pred == 1 and label == 1:
tp += 1
return tp
def true_negatives(y_true, y_pred):
tn = 0
for ... | null |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.