repo
stringlengths 1
99
| file
stringlengths 13
215
| code
stringlengths 12
59.2M
| file_length
int64 12
59.2M
| avg_line_length
float64 3.82
1.48M
| max_line_length
int64 12
2.51M
| extension_type
stringclasses 1
value |
|---|---|---|---|---|---|---|
fitclip | fitclip-main/aligner/encoder/videoclip_video_text_encoder.py | import os
from typing import Iterable, Iterator, Optional
import torch
from overrides import overrides
from torchvision import transforms as T
from transformers import AutoTokenizer
from aligner.data.frame_sampler import ConsecutiveFrameSampler, FrameSampler
from aligner.encoder.s3dg import S3DG
from aligner.encoder.video_encoder import TYPE_TRANSFORM, TYPE_VIDEO_INPUT, float_standard_denormalize
from aligner.encoder.video_text_encoder import TYPE_TEXT_INPUT, TYPE_TOKENIZER, VideoTextEncoder
from aligner.encoder.videoclip import MMFusionSeparate
from aligner.transforms import ConvertBHWCtoCBHW, PadToMinFrames
from util.typing_utils import TYPE_PATH
class VideoClipVideoTextEncoder(VideoTextEncoder):
def __init__(self, video_encoder_pretrained_path: Optional[TYPE_PATH] = None,
model_pretrained_path: Optional[TYPE_PATH] = None, num_frames: int = 32, max_tokens: int = 64) -> None:
super().__init__()
self.num_frames = num_frames
self.max_tokens = max_tokens
self.video_encoder = S3DG()
if video_encoder_pretrained_path:
self.video_encoder.load_state_dict(torch.load(video_encoder_pretrained_path))
self.model = MMFusionSeparate(max_video_len=num_frames)
if model_pretrained_path:
self.model.load_state_dict(torch.load(model_pretrained_path))
os.environ["TOKENIZERS_PARALLELISM"] = "0"
self.tokenizer = AutoTokenizer.from_pretrained(self.model.model_name)
@overrides(check_signature=False)
def encode_video(self, video: TYPE_VIDEO_INPUT) -> torch.Tensor:
batch_size, clip_count = video.shape[:2]
assert batch_size == 1, "Only batch_size = 1 is supported for now."
device = video.device
# FIXME: VideoCLIP uses up to 32 clips per video, which complicates our implementation.
# These clips are randomly sampled when there's more than 32 clips.
# These clips are composed of non-overlapping 32 consecutive frames, and the video is sampled at 30 fps.
video_features = self.video_encoder(video).view(batch_size, clip_count, self.video_encoder.output_size)
video_mask = torch.ones((batch_size, self.num_frames), dtype=torch.bool, device=device)
text = torch.tensor([[self.tokenizer.cls_token_id, self.tokenizer.sep_token_id]], device=device) \
.expand(batch_size, 2)
text_mask = torch.ones((batch_size, 2), dtype=torch.bool, device=device)
return self.model.forward_video(video_features, video_mask, text, text_mask)
@overrides(check_signature=False)
def encode_text(self, text: TYPE_TEXT_INPUT) -> torch.Tensor:
return self.model.forward_text(text["input_ids"], text["attention_mask"])
def _tokenize(self, texts: Iterable[str]) -> TYPE_TEXT_INPUT:
texts = [f"{self.tokenizer.sep_token} {text}" for text in texts]
return self.tokenizer(texts, return_tensors="pt", padding=True, truncation=True, max_length=self.max_tokens)
@overrides
def get_tokenizer(self) -> TYPE_TOKENIZER:
return self._tokenize
@overrides
def decode_text(self, text: TYPE_TEXT_INPUT) -> Iterator[str]:
return self.tokenizer.batch_decode(text["input_ids"])
@overrides
def get_train_frame_sampler(self) -> FrameSampler:
raise NotImplementedError
@overrides
def get_eval_frame_sampler(self) -> FrameSampler:
return ConsecutiveFrameSampler(self.num_frames, fps=30)
@overrides
def get_train_transform(self, dtype: torch.dtype) -> TYPE_TRANSFORM:
raise NotImplementedError
@overrides
def get_eval_transform(self, dtype: torch.dtype) -> TYPE_TRANSFORM:
return T.Compose([
ConvertBHWCtoCBHW(),
T.ConvertImageDtype(dtype),
T.Resize(224),
T.CenterCrop(224),
PadToMinFrames(self.num_frames, frame_dim=1),
])
@property
@overrides
def should_pad_batch(self) -> bool:
return False
@overrides
def to_bchw(self, t: torch.Tensor) -> torch.Tensor:
return t.permute(0, 2, 1, 3, 4)
@overrides
def denormalize_video_tensor(self, video: TYPE_VIDEO_INPUT) -> torch.Tensor:
return float_standard_denormalize(video)
| 4,268 | 39.657143 | 120 | py |
fitclip | fitclip-main/aligner/encoder/mil_nce_video_text_encoder.py | import re
from typing import Any, Iterable, Iterator, Mapping, Optional, Union
import numpy as np
import torch
from cached_path import cached_path
from overrides import overrides
from torch import nn
from torchvision import transforms as T
from aligner.data.frame_sampler import ConsecutiveFrameSampler, FrameSampler
from aligner.encoder.s3dg import S3DG
from aligner.encoder.video_encoder import TYPE_TRANSFORM, float_standard_denormalize
from aligner.encoder.video_text_encoder import TYPE_TEXT_INPUT, TYPE_TOKENIZER, TYPE_VIDEO_INPUT, VideoTextEncoder
from aligner.transforms import ConvertBHWCtoCBHW, PadToMinFrames
from util.typing_utils import TYPE_PATH
def load_pretrained_video_encoder(path: TYPE_PATH,
map_location: Optional[Union[str, torch.device]] = None) -> Mapping[str, Any]:
checkpoint = torch.load(path, map_location=map_location)
state_dict = get_video_encoder_state_dict_from_pretrained_mil_nce_checkpoint(checkpoint) \
if "state_dict" in checkpoint else checkpoint
# Backward compatibility, also with the MIL-NCE paper pretrained one.
return {k: v for k, v in state_dict.items() if not k.startswith("text_module.")}
def load_pretrained_text_encoder(path: TYPE_PATH,
map_location: Optional[Union[str, torch.device]] = None) -> Mapping[str, Any]:
checkpoint = torch.load(path, map_location=map_location)
if "state_dict" in checkpoint:
return get_text_encoder_state_dict_from_pretrained_mil_nce_checkpoint(checkpoint)
elif any(k.startswith("text_module.") for k in checkpoint):
# Backward compatibility, also with a MIL-NCE paper pretrained one.
prefix = "text_module."
return {k[len(prefix):]: v for k, v in checkpoint.items() if k.startswith(prefix)}
else:
return checkpoint
def get_video_encoder_state_dict_from_pretrained_mil_nce_checkpoint(
checkpoint: Mapping[str, Any]) -> Mapping[str, torch.Tensor]:
pl_module_state_dict = checkpoint["state_dict"]
# Look for the corresponding encoder, with backward compatibility.
prefix = "encoder." if any(k.startswith("encoder.") for k in pl_module_state_dict.keys()) else "video_encoder."
return {k[len(prefix):]: v for k, v in pl_module_state_dict.items() if k.startswith(prefix)}
def get_text_encoder_state_dict_from_pretrained_mil_nce_checkpoint(
checkpoint: Mapping[str, Any]) -> Mapping[str, torch.Tensor]:
pl_module_state_dict = checkpoint["state_dict"]
# Look for the corresponding encoder, with backward compatibility.
prefix = "encoder.text_module." if any(k.startswith("encoder.text_module.") for k in pl_module_state_dict.keys()) \
else "text_encoder."
return {k[len(prefix):]: v for k, v in pl_module_state_dict.items() if k.startswith(prefix)}
class GlobalMaxPool1d(nn.Module):
@overrides(check_signature=False)
def forward(self, t: torch.Tensor) -> torch.Tensor:
return t.max(dim=1)[0]
class MilNceTextEncoder(nn.Module):
def __init__(self, output_size: int = 512, vocab_size: int = 66250, word_embedding_size: int = 300,
embedding: Optional[torch.Tensor] = None, hidden_size: int = 2048) -> None:
super().__init__()
# noinspection SpellCheckingInspection
self.word_embd = nn.Embedding(vocab_size, word_embedding_size) if embedding is None \
else nn.Embedding.from_pretrained(embedding)
self.fc1 = nn.Linear(self.word_embd.embedding_dim, hidden_size)
self.relu = nn.ReLU(inplace=True)
self.max_pooling = GlobalMaxPool1d()
self.fc2 = nn.Linear(hidden_size, output_size)
@overrides(check_signature=False)
def forward(self, input_ids: torch.Tensor) -> torch.Tensor:
text = self.word_embd(input_ids)
text = self.relu(self.fc1(text))
text = self.max_pooling(text)
return self.fc2(text)
def truncate_or_pad_1d_tensor(tensor: torch.Tensor, size: int, fill_value: Any = 0) -> torch.Tensor:
if len(tensor) >= size:
return tensor[:size]
else:
padded_tensor = torch.full((size,), fill_value, dtype=tensor.dtype, device=tensor.device,
requires_grad=tensor.requires_grad)
padded_tensor[:len(tensor)] = tensor
return padded_tensor
class MilNceTokenizer:
RE_WORD = re.compile(r"[\w']+")
def __init__(self, vocab: Mapping[str, int], max_tokens: int = 20, lowercase: bool = True) -> None:
super().__init__()
self.vocab = vocab
self.max_tokens = max_tokens
self.lowercase = lowercase
self.indices_to_tokens = {i: token for token, i in vocab.items()}
def _tokenize(self, text: str) -> Iterator[str]:
if self.lowercase:
text = text.lower()
return self.RE_WORD.findall(text)
def _index(self, tokens: Iterable[str]) -> torch.Tensor:
tokens_in_vocab_tensor = torch.tensor([self.vocab[word] for word in tokens if word in self.vocab],
dtype=torch.long)
return truncate_or_pad_1d_tensor(tokens_in_vocab_tensor, self.max_tokens)
def __call__(self, text: str) -> TYPE_TEXT_INPUT:
return {"input_ids": self._index(self._tokenize(text))}
def decode(self, ids: Iterable[int]) -> str:
return " ".join(self.indices_to_tokens[i] for i in ids if i != 0)
class MilNceVideoTextEncoder(VideoTextEncoder):
def __init__(self, vocab_path: TYPE_PATH = "https://www.rocq.inria.fr/cluster-willow/amiech/howto100m/s3d_dict.npy",
pretrained_path: Optional[TYPE_PATH] = None, max_tokens: int = 20, num_frames: int = 16) -> None:
super().__init__()
self.video_encoder = S3DG()
self.text_encoder = MilNceTextEncoder()
vocab: Mapping[str, int] = {t.item(): i + 1 for i, t in enumerate(np.load(cached_path(vocab_path)))}
self.tokenizer = MilNceTokenizer(vocab=vocab, max_tokens=max_tokens)
self.num_frames = num_frames
if pretrained_path:
pretrained_path = cached_path(pretrained_path)
self.video_encoder.load_state_dict(load_pretrained_video_encoder(pretrained_path, # noqa
map_location="cpu"))
self.text_encoder.load_state_dict(load_pretrained_text_encoder(pretrained_path, # noqa
map_location="cpu"))
@overrides(check_signature=False)
def encode_video(self, video: TYPE_VIDEO_INPUT) -> torch.Tensor:
return self.video_encoder(video)
@overrides(check_signature=False)
def encode_text(self, text: TYPE_TEXT_INPUT) -> torch.Tensor:
return self.text_encoder(text["input_ids"])
def _tokenize(self, texts: Iterable[str]) -> TYPE_TEXT_INPUT:
tokenized = [self.tokenizer(text) for text in texts]
return {k: torch.stack([t[k] for t in tokenized]) for k in next(iter(tokenized), [])}
@overrides
def get_tokenizer(self) -> TYPE_TOKENIZER:
return self._tokenize
@overrides
def decode_text(self, text: TYPE_TEXT_INPUT) -> Iterator[str]:
for text_instance in text["input_ids"]:
yield self.tokenizer.decode(text_instance.tolist())
@overrides
def get_train_frame_sampler(self) -> FrameSampler:
raise NotImplementedError
@overrides
def get_eval_frame_sampler(self) -> FrameSampler:
return ConsecutiveFrameSampler(self.num_frames, fps=5)
@overrides
def get_train_transform(self, dtype: torch.dtype) -> TYPE_TRANSFORM:
raise NotImplementedError
@overrides
def get_eval_transform(self, dtype: torch.dtype) -> TYPE_TRANSFORM:
return T.Compose([
ConvertBHWCtoCBHW(),
T.ConvertImageDtype(dtype),
T.Resize(224),
T.CenterCrop(224),
PadToMinFrames(self.num_frames, frame_dim=1),
])
@property
@overrides
def should_pad_batch(self) -> bool:
return False
@overrides
def to_bchw(self, t: torch.Tensor) -> torch.Tensor:
return t.permute(0, 2, 1, 3, 4)
@overrides
def denormalize_video_tensor(self, video: TYPE_VIDEO_INPUT) -> torch.Tensor:
return float_standard_denormalize(video)
| 8,365 | 41.040201 | 120 | py |
fitclip | fitclip-main/aligner/encoder/video_text_encoder.py | from abc import abstractmethod
from typing import Callable, Iterable, Iterator, Mapping, Tuple
import torch
from overrides import overrides
from aligner.encoder.video_encoder import TYPE_VIDEO_INPUT, VideoEncoder
TYPE_TEXT_INPUT = Mapping[str, torch.Tensor]
TYPE_OUTPUT = Tuple[torch.Tensor, torch.Tensor]
TYPE_TOKENIZER = Callable[[Iterable[str]], Mapping[str, torch.Tensor]]
class VideoTextEncoder(VideoEncoder):
@abstractmethod
def encode_text(self, text: TYPE_TEXT_INPUT) -> torch.Tensor:
raise NotImplementedError
@overrides(check_signature=False)
def forward(self, video: TYPE_VIDEO_INPUT, text: TYPE_TEXT_INPUT) -> TYPE_OUTPUT:
return self.encode_video(video), self.encode_text(text)
@abstractmethod
def get_tokenizer(self) -> TYPE_TOKENIZER:
raise NotImplementedError
@abstractmethod
def decode_text(self, text: TYPE_TEXT_INPUT) -> Iterator[str]:
"""Decodes a batch of texts."""
raise NotImplementedError
| 994 | 30.09375 | 85 | py |
fitclip | fitclip-main/aligner/encoder/video_encoder.py | from abc import abstractmethod
from typing import Callable, Optional, Tuple
import torch
from overrides import overrides
from torch import nn
from aligner.data.frame_sampler import FrameSampler
TYPE_VIDEO_INPUT = torch.Tensor
TYPE_TRANSFORM = Callable[[torch.Tensor], torch.Tensor]
class VideoEncoder(nn.Module):
@abstractmethod
def encode_video(self, video: TYPE_VIDEO_INPUT) -> torch.Tensor:
raise NotImplementedError
@overrides(check_signature=False)
def forward(self, video: TYPE_VIDEO_INPUT) -> torch.Tensor:
return self.encode_video(video)
@abstractmethod
def get_train_frame_sampler(self) -> FrameSampler:
raise NotImplementedError
@abstractmethod
def get_eval_frame_sampler(self) -> FrameSampler:
raise NotImplementedError
@abstractmethod
def get_train_transform(self, dtype: torch.dtype) -> TYPE_TRANSFORM:
raise NotImplementedError
@abstractmethod
def get_eval_transform(self, dtype: torch.dtype) -> TYPE_TRANSFORM:
raise NotImplementedError
@property
# Don't set as abstract method to avoid some boilerplate in subclasses.
# See https://stackoverflow.com/a/42529760/1165181
def should_pad_batch(self) -> bool:
raise NotImplementedError
@abstractmethod
def to_bchw(self, t: torch.Tensor) -> torch.Tensor:
raise NotImplementedError
@abstractmethod
def denormalize_video_tensor(self, video: TYPE_VIDEO_INPUT) -> torch.Tensor:
"""Converts a transformed video tensor into an unsigned 8-bit integer tensor in the range 0-255."""
raise NotImplementedError
def float_standard_denormalize(video: TYPE_VIDEO_INPUT, mean: Optional[Tuple[float, float, float]] = None,
std: Optional[Tuple[float, float, float]] = None) -> torch.Tensor:
if std is not None:
video *= torch.tensor(std, device=video.device, dtype=video.dtype).view(-1, 1, 1)
if mean is not None:
video += torch.tensor(mean, device=video.device, dtype=video.dtype).view(-1, 1, 1)
return (video * 255).to(torch.uint8) # noqa
| 2,121 | 32.15625 | 107 | py |
fitclip | fitclip-main/aligner/encoder/slip.py | # Copyright (c) Meta Platforms, Inc. and affiliates.
# All rights reserved.
# Copied from https://github.com/facebookresearch/SLIP/tree/c6faf5d
import gzip
import html
from collections import OrderedDict
from functools import lru_cache
from typing import Iterable, Iterator
import ftfy
import numpy as np
import regex as re
import timm
import torch
import torch.distributed as dist
import torch.nn as nn
import torch.nn.functional as F
from cached_path import cached_path
from torch import autograd
@lru_cache()
def default_bpe():
return cached_path("https://github.com/facebookresearch/SLIP/raw/main/bpe_simple_vocab_16e6.txt.gz")
@lru_cache()
def bytes_to_unicode():
"""
Returns list of utf-8 byte and a corresponding list of unicode strings.
The reversible bpe codes work on unicode strings.
This means you need a large # of unicode characters in your vocab if you want to avoid UNKs.
When you're at something like a 10B token dataset you end up needing around 5K for decent coverage.
This is a significant percentage of your normal, say, 32K bpe vocab.
To avoid that, we want lookup tables between utf-8 bytes and unicode strings.
And avoids mapping to whitespace/control characters the bpe code barfs on.
"""
bs = list(range(ord("!"), ord("~") + 1)) + list(range(ord("¡"), ord("¬") + 1)) + list(range(ord("®"), ord("ÿ") + 1))
cs = bs[:]
n = 0
for b in range(2 ** 8):
if b not in bs:
bs.append(b)
cs.append(2 ** 8 + n)
n += 1
cs = [chr(n) for n in cs]
return dict(zip(bs, cs))
def get_pairs(word):
"""Return set of symbol pairs in a word.
Word is represented as tuple of symbols (symbols being variable-length strings).
"""
pairs = set()
prev_char = word[0]
for char in word[1:]:
pairs.add((prev_char, char))
prev_char = char
return pairs
def basic_clean(text):
text = ftfy.fix_text(text)
text = html.unescape(html.unescape(text))
return text.strip()
def whitespace_clean(text):
text = re.sub(r'\s+', ' ', text)
text = text.strip()
return text
class SimpleTokenizer:
def __init__(self, bpe_path: str = default_bpe()):
self.byte_encoder = bytes_to_unicode()
self.byte_decoder = {v: k for k, v in self.byte_encoder.items()}
merges = gzip.open(bpe_path).read().decode("utf-8").split('\n')
merges = merges[1:49152 - 256 - 2 + 1]
merges = [tuple(merge.split()) for merge in merges]
vocab = list(bytes_to_unicode().values())
vocab = vocab + [v + '</w>' for v in vocab]
for merge in merges:
vocab.append(''.join(merge))
vocab.extend(['<|startoftext|>', '<|endoftext|>'])
self.encoder = dict(zip(vocab, range(len(vocab))))
self.decoder = {v: k for k, v in self.encoder.items()}
self.bpe_ranks = dict(zip(merges, range(len(merges))))
self.cache = {'<|startoftext|>': '<|startoftext|>', '<|endoftext|>': '<|endoftext|>'}
self.pat = re.compile(
r"""<\|startoftext\|>|<\|endoftext\|>|'s|'t|'re|'ve|'m|'ll|'d|[\p{L}]+|[\p{N}]|[^\s\p{L}\p{N}]+""",
re.IGNORECASE)
def bpe(self, token):
if token in self.cache:
return self.cache[token]
word = tuple(token[:-1]) + (token[-1] + '</w>',)
pairs = get_pairs(word)
if not pairs:
return token + '</w>'
while True:
bigram = min(pairs, key=lambda pair: self.bpe_ranks.get(pair, float('inf')))
if bigram not in self.bpe_ranks:
break
first, second = bigram
new_word = []
i = 0
while i < len(word):
try:
j = word.index(first, i)
new_word.extend(word[i:j])
i = j
except:
new_word.extend(word[i:])
break
if word[i] == first and i < len(word) - 1 and word[i + 1] == second:
new_word.append(first + second)
i += 2
else:
new_word.append(word[i])
i += 1
new_word = tuple(new_word)
word = new_word
if len(word) == 1:
break
else:
pairs = get_pairs(word)
word = ' '.join(word)
self.cache[token] = word
return word
def encode(self, text):
bpe_tokens = []
text = whitespace_clean(basic_clean(text)).lower()
for token in re.findall(self.pat, text):
token = ''.join(self.byte_encoder[b] for b in token.encode('utf-8'))
bpe_tokens.extend(self.encoder[bpe_token] for bpe_token in self.bpe(token).split(' '))
return bpe_tokens
def decode(self, tokens):
text = ''.join(self.decoder[token] for token in tokens)
text = bytearray([self.byte_decoder[c] for c in text]).decode('utf-8', errors="replace").replace('</w>', ' ')
return text
def __call__(self, texts, context_length=77):
if isinstance(texts, str):
texts = [texts]
sot_token = self.encoder["<|startoftext|>"]
eot_token = self.encoder["<|endoftext|>"]
all_tokens = [[sot_token] + self.encode(text) + [eot_token] for text in texts]
result = torch.zeros(len(all_tokens), context_length, dtype=torch.long)
for i, tokens in enumerate(all_tokens):
tokens = tokens[:context_length]
result[i, :len(tokens)] = torch.tensor(tokens)
if len(result) == 1:
return result[0]
return result
def is_dist_avail_and_initialized() -> bool:
return dist.is_available() and dist.is_initialized()
def get_world_size() -> int:
return dist.get_world_size() if is_dist_avail_and_initialized() else 1
def get_rank() -> int:
return dist.get_rank() if is_dist_avail_and_initialized() else 0
def all_gather_batch(tensors):
"""
Performs all_gather operation on the provided tensors.
"""
# Queue the gathered tensors
world_size = get_world_size()
# There is no need for reduction in the single-proc case
if world_size == 1:
return tensors
tensor_list = []
for tensor in tensors:
tensor_all = [torch.ones_like(tensor) for _ in range(world_size)]
dist.all_gather(
tensor_all,
tensor,
async_op=False # performance opt
)
tensor_list.append(tensor_all)
return [torch.cat(tensor_all) for tensor_all in tensor_list]
class GatherLayer(autograd.Function): # noqa
"""
Gather tensors from all workers with support for backward propagation:
This implementation does not cut the gradients as torch.distributed.all_gather does.
"""
@staticmethod
def forward(ctx, x): # noqa
output = [torch.zeros_like(x) for _ in range(dist.get_world_size())]
dist.all_gather(output, x)
return tuple(output)
@staticmethod
def backward(ctx, *grads):
all_gradients = torch.stack(grads)
dist.all_reduce(all_gradients)
return all_gradients[dist.get_rank()]
def all_gather_batch_with_grad(tensors: Iterable[torch.Tensor]) -> Iterator[torch.Tensor]:
"""
Performs all_gather operation on the provided tensors.
Graph remains connected for backward grad computation.
"""
return tensors if get_world_size() == 1 else [torch.cat(GatherLayer.apply(tensor)) for tensor in tensors]
class CLIPLoss(nn.Module):
def __init__(self):
super().__init__()
self.labels = None
self.last_local_batch_size = None
def forward(self, outputs):
image_embed = outputs['image_embed']
text_embed = outputs['text_embed']
logit_scale = outputs['logit_scale']
local_batch_size = image_embed.size(0)
if local_batch_size != self.last_local_batch_size:
self.labels = local_batch_size * get_rank() + torch.arange(
local_batch_size, device=image_embed.device
)
self.last_local_batch_size = local_batch_size
# normalized features
image_embed = F.normalize(image_embed, dim=-1, p=2)
text_embed = F.normalize(text_embed, dim=-1, p=2)
# gather features from all GPUs
image_embed_all, text_embed_all = all_gather_batch([image_embed, text_embed])
# cosine similarity as logits
logits_per_image = logit_scale * image_embed @ text_embed_all.t()
logits_per_text = logit_scale * text_embed @ image_embed_all.t()
loss = (F.cross_entropy(logits_per_image, self.labels) + F.cross_entropy(logits_per_text, self.labels)) / 2
# compute accuracy
with torch.no_grad():
pred = torch.argmax(logits_per_image, dim=-1)
correct = pred.eq(self.labels).sum()
acc = 100 * correct / local_batch_size
return {'loss': loss, 'clip_loss': loss, 'clip_acc': acc}
class SIMCLRLoss(nn.Module):
"""
This is the SimCLR loss in https://arxiv.org/abs/2002.05709
The embedding vectors are assumed to have size (2 x batch_size, embedding_dim) and
the memory layout that can be reshaped into shape (2, batch_size, embedding_dim).
This memory layout is consistent with the SimCLR collator in
https://github.com/facebookresearch/vissl/blob/master/vissl/data/collators/simclr_collator.py
Config params:
temperature (float): the temperature to be applied on the logits
"""
def __init__(self, temperature=0.1):
super().__init__()
self.tau = temperature
self.labels = None
self.masks = None
self.last_local_batch_size = None
def forward(self, outputs):
q_a = outputs['aug1_embed']
q_b = outputs['aug2_embed']
q_a = F.normalize(q_a, dim=-1, p=2)
q_b = F.normalize(q_b, dim=-1, p=2)
local_batch_size = q_a.size(0)
k_a, k_b = all_gather_batch_with_grad([q_a, q_b])
if local_batch_size != self.last_local_batch_size:
self.labels = local_batch_size * get_rank() + torch.arange(
local_batch_size, device=q_a.device
)
total_batch_size = local_batch_size * get_world_size()
self.masks = F.one_hot(self.labels, total_batch_size) * 1e9
self.last_local_batch_size = local_batch_size
logits_aa = torch.matmul(q_a, k_a.transpose(0, 1)) / self.tau
logits_aa = logits_aa - self.masks
logits_bb = torch.matmul(q_b, k_b.transpose(0, 1)) / self.tau
logits_bb = logits_bb - self.masks
logits_ab = torch.matmul(q_a, k_b.transpose(0, 1)) / self.tau
logits_ba = torch.matmul(q_b, k_a.transpose(0, 1)) / self.tau
loss_a = F.cross_entropy(torch.cat([logits_ab, logits_aa], dim=1), self.labels)
loss_b = F.cross_entropy(torch.cat([logits_ba, logits_bb], dim=1), self.labels)
loss = (loss_a + loss_b) / 2 # divide by 2 to average over all samples
# compute accuracy
with torch.no_grad():
pred = torch.argmax(torch.cat([logits_ab, logits_aa], dim=1), dim=-1)
correct = pred.eq(self.labels).sum()
acc = 100 * correct / local_batch_size
return {'loss': loss, 'ssl_loss': loss, 'ssl_acc': acc}
class SLIPLoss(nn.Module):
def __init__(self, ssl_loss, ssl_scale):
super().__init__()
self.clip_loss = CLIPLoss()
self.ssl_loss = ssl_loss
self.ssl_scale = ssl_scale
def forward(self, outputs):
clip_loss_dict = self.clip_loss(outputs)
clip_loss = clip_loss_dict['clip_loss']
clip_acc = clip_loss_dict['clip_acc']
ssl_loss_dict = self.ssl_loss(outputs)
ssl_loss = ssl_loss_dict['ssl_loss']
ssl_acc = ssl_loss_dict['ssl_acc']
return {'loss': clip_loss + self.ssl_scale * ssl_loss,
'clip_loss': clip_loss,
'clip_acc': clip_acc,
'ssl_loss': ssl_loss,
'ssl_acc': ssl_acc}
class LayerNorm(nn.LayerNorm):
"""Subclass torch's LayerNorm to handle fp16."""
def forward(self, x: torch.Tensor):
orig_type = x.dtype
ret = super().forward(x.type(torch.float32))
return ret.type(orig_type)
class QuickGELU(nn.Module):
def forward(self, x: torch.Tensor): # noqa
return x * torch.sigmoid(1.702 * x) # noqa
class ResidualAttentionBlock(nn.Module):
def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None):
super().__init__()
self.attn = nn.MultiheadAttention(d_model, n_head)
self.ln_1 = LayerNorm(d_model)
self.mlp = nn.Sequential(OrderedDict([
("c_fc", nn.Linear(d_model, d_model * 4)),
("gelu", QuickGELU()),
("c_proj", nn.Linear(d_model * 4, d_model))
]))
self.ln_2 = LayerNorm(d_model)
self.attn_mask = attn_mask
def attention(self, x: torch.Tensor):
self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None
return self.attn(x, x, x, need_weights=False, attn_mask=self.attn_mask)[0]
def forward(self, x: torch.Tensor):
x = x + self.attention(self.ln_1(x))
x = x + self.mlp(self.ln_2(x))
return x
class Transformer(nn.Module):
def __init__(self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None):
super().__init__()
self.width = width
self.layers = layers
self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)])
def forward(self, x: torch.Tensor):
return self.resblocks(x)
class CLIP(nn.Module):
def __init__(self,
embed_dim: int,
# vision
vision_width: int,
vision_model: nn.Module,
# text
context_length: int,
vocab_size: int,
transformer_width: int,
transformer_heads: int,
transformer_layers: int,
**kwargs,
):
super().__init__()
self.context_length = context_length
self.vision_width = vision_width
self.visual = vision_model
self.transformer = Transformer(
width=transformer_width,
layers=transformer_layers,
heads=transformer_heads,
attn_mask=self.build_attention_mask(),
)
self.vocab_size = vocab_size
self.token_embedding = nn.Embedding(vocab_size, transformer_width)
self.positional_embedding = nn.Parameter(torch.empty(self.context_length, transformer_width))
self.ln_final = LayerNorm(transformer_width)
self.image_projection = nn.Parameter(torch.empty(vision_width, embed_dim))
self.text_projection = nn.Parameter(torch.empty(transformer_width, embed_dim))
self.logit_scale = nn.Parameter(torch.ones([]) * np.log(1 / 0.07))
self.initialize_parameters()
def initialize_parameters(self):
nn.init.normal_(self.token_embedding.weight, std=0.02)
nn.init.normal_(self.positional_embedding, std=0.01)
proj_std = (self.transformer.width ** -0.5) * ((2 * self.transformer.layers) ** -0.5)
attn_std = self.transformer.width ** -0.5
fc_std = (2 * self.transformer.width) ** -0.5
for block in self.transformer.resblocks:
nn.init.normal_(block.attn.in_proj_weight, std=attn_std)
nn.init.normal_(block.attn.out_proj.weight, std=proj_std)
nn.init.normal_(block.mlp.c_fc.weight, std=fc_std)
nn.init.normal_(block.mlp.c_proj.weight, std=proj_std)
nn.init.normal_(self.image_projection, std=self.vision_width ** -0.5)
nn.init.normal_(self.text_projection, std=self.transformer.width ** -0.5)
def build_attention_mask(self):
# lazily create causal attention mask, with full attention between the vision tokens
# pytorch uses additive attention mask; fill with -inf
mask = torch.empty(self.context_length, self.context_length)
mask.fill_(float("-inf"))
mask.triu_(1) # zero out the lower diagonal
return mask
def encode_image(self, image):
x = self.visual(image)
x = x @ self.image_projection
return x
def encode_text(self, text):
x = self.token_embedding(text) # [batch_size, n_ctx, d_model]
x = x + self.positional_embedding
x = x.permute(1, 0, 2) # NLD -> LND
x = self.transformer(x)
x = x.permute(1, 0, 2) # LND -> NLD
x = self.ln_final(x)
# x.shape = [batch_size, n_ctx, transformer.width]
# take features from the eot embedding (eot_token is the highest number in each sequence)
x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection
return x
def forward(self, image, text):
image_embed = self.encode_image(image)
text_embed = self.encode_text(text)
return {'image_embed': image_embed,
'text_embed': text_embed,
'logit_scale': self.logit_scale.exp()}
def _build_mlp(in_dim, mlp_dim, out_dim):
return nn.Sequential(OrderedDict([
("layer1", nn.Linear(in_dim, mlp_dim)),
("bn1", nn.SyncBatchNorm(mlp_dim)),
("relu1", nn.ReLU(inplace=True)),
("layer2", nn.Linear(mlp_dim, mlp_dim)),
("bn2", nn.SyncBatchNorm(mlp_dim)),
("relu2", nn.ReLU(inplace=True)),
("layer3", nn.Linear(mlp_dim, out_dim)),
]))
class SIMCLR(nn.Module):
def __init__(self,
# vision
vision_width: int,
vision_model: nn.Module,
# ssl
ssl_mlp_dim: int,
ssl_emb_dim: int,
**kwargs, # noqa
):
super().__init__()
self.vision_width = vision_width
self.visual = vision_model
self.image_mlp = _build_mlp(in_dim=vision_width, mlp_dim=ssl_mlp_dim, out_dim=ssl_emb_dim)
def encode_image(self, image):
return self.visual(image)
def forward(self, aug1, aug2):
h1 = self.visual(aug1)
h2 = self.visual(aug2)
aug1_embed = self.image_mlp(h1)
aug2_embed = self.image_mlp(h2)
return {'aug1_embed': aug1_embed, 'aug2_embed': aug2_embed}
class SLIP(CLIP):
def __init__(self, ssl_mlp_dim: int, ssl_emb_dim: int, **kwargs):
super().__init__(**kwargs)
self.image_mlp = _build_mlp(in_dim=self.vision_width, mlp_dim=ssl_mlp_dim, out_dim=ssl_emb_dim)
def forward(self, image, text, aug1, aug2): # noqa
aug1_embed = self.image_mlp(self.visual(aug1))
aug2_embed = self.image_mlp(self.visual(aug2))
image_embed = self.encode_image(image)
text_embed = self.encode_text(text)
return {'image_embed': image_embed, 'text_embed': text_embed, 'logit_scale': self.logit_scale.exp(),
'aug1_embed': aug1_embed, 'aug2_embed': aug2_embed}
def get_loss(model, ssl_temp, ssl_scale):
if model.startswith('SLIP'):
ssl_loss = SIMCLRLoss(temperature=ssl_temp)
return SLIPLoss(ssl_loss, ssl_scale)
if model.startswith('CLIP'):
return CLIPLoss()
if model.startswith('SIMCLR'):
return SIMCLRLoss(temperature=ssl_temp)
def get_metric_names(model):
if model.startswith('SLIP'):
return ['loss', 'clip_loss', 'ssl_loss', 'clip_acc', 'ssl_acc']
elif model.startswith('CLIP'):
return ['loss', 'clip_loss', 'clip_acc']
else:
return ['loss', 'ssl_loss', 'ssl_acc']
@timm.models.registry.register_model
def vit_small_mocov3_patch16_224(**kwargs):
return timm.models.vision_transformer._create_vision_transformer("vit_small_patch16_224", patch_size=16,
embed_dim=384, depth=12, num_heads=12, **kwargs)
def CLIP_VITS16(**kwargs):
vision_model = timm.create_model('vit_small_mocov3_patch16_224', num_classes=0)
model = CLIP(embed_dim=512, vision_width=384, vision_model=vision_model, context_length=77, vocab_size=49408,
transformer_width=512, transformer_heads=8, transformer_layers=12, **kwargs)
return model
def SIMCLR_VITS16(**kwargs):
vision_model = timm.create_model('vit_small_mocov3_patch16_224', num_classes=0)
model = SIMCLR(vision_width=384, vision_model=vision_model, **kwargs)
return model
def SLIP_VITS16(**kwargs):
vision_model = timm.create_model('vit_small_mocov3_patch16_224', num_classes=0)
model = SLIP(embed_dim=512, vision_width=384, vision_model=vision_model, context_length=77, vocab_size=49408,
transformer_width=512, transformer_heads=8, transformer_layers=12, **kwargs)
return model
def CLIP_VITB16(**kwargs):
vision_model = timm.create_model('vit_base_patch16_224', num_classes=0)
model = CLIP(embed_dim=512, vision_width=768, vision_model=vision_model, context_length=77, vocab_size=49408,
transformer_width=512, transformer_heads=8, transformer_layers=12, **kwargs)
return model
def SIMCLR_VITB16(**kwargs):
vision_model = timm.create_model('vit_base_patch16_224', num_classes=0)
model = SIMCLR(vision_width=768, vision_model=vision_model, **kwargs)
return model
def SLIP_VITB16(**kwargs):
vision_model = timm.create_model('vit_base_patch16_224', num_classes=0)
model = SLIP(embed_dim=512, vision_width=768, vision_model=vision_model, context_length=77, vocab_size=49408,
transformer_width=512, transformer_heads=8, transformer_layers=12, **kwargs)
return model
def CLIP_VITL16(**kwargs):
vision_model = timm.create_model('vit_large_patch16_224', num_classes=0)
model = CLIP(embed_dim=512, vision_width=1024, vision_model=vision_model, context_length=77, vocab_size=49408,
transformer_width=512, transformer_heads=8, transformer_layers=12, **kwargs)
return model
def SIMCLR_VITL16(**kwargs):
vision_model = timm.create_model('vit_large_patch16_224', num_classes=0)
model = SIMCLR(vision_width=1024, vision_model=vision_model, **kwargs)
return model
def SLIP_VITL16(**kwargs):
vision_model = timm.create_model('vit_large_patch16_224', num_classes=0)
model = SLIP(embed_dim=512, vision_width=1024, vision_model=vision_model, context_length=77, vocab_size=49408,
transformer_width=512, transformer_heads=8, transformer_layers=12, **kwargs)
return model
| 22,773 | 34.640063 | 120 | py |
fitclip | fitclip-main/aligner/encoder/s3dg.py | # Initially copied from the MIL-NCE repo.
"""Contains the definition for Gated Separable 3D network (S3D-G). """
from typing import Literal, Tuple
import torch
from overrides import overrides
from torch import nn
from torch.nn.common_types import _size_3_t, _size_6_t
class InceptionBlock(nn.Module):
def __init__(self, input_dim: int, num_outputs_0_0a: int, num_outputs_1_0a: int, num_outputs_1_0b: int,
num_outputs_2_0a: int, num_outputs_2_0b: int, num_outputs_3_0b: int, gating: bool = True) -> None:
super().__init__()
self.conv_b0 = STConv3D(input_dim, num_outputs_0_0a, kernel_size=1)
self.conv_b1_a = STConv3D(input_dim, num_outputs_1_0a, kernel_size=1)
self.conv_b1_b = STConv3D(num_outputs_1_0a, num_outputs_1_0b, kernel_size=3, padding=1, separable=True)
self.conv_b2_a = STConv3D(input_dim, num_outputs_2_0a, kernel_size=1)
self.conv_b2_b = STConv3D(num_outputs_2_0a, num_outputs_2_0b, kernel_size=3, padding=1, separable=True)
self.maxpool_b3 = torch.nn.MaxPool3d(kernel_size=3, stride=1, padding=1)
self.conv_b3_b = STConv3D(input_dim, num_outputs_3_0b, 1)
self.gating = gating
self.output_dim = num_outputs_0_0a + num_outputs_1_0b + num_outputs_2_0b + num_outputs_3_0b
if gating:
self.gating_b0 = SelfGating(num_outputs_0_0a)
self.gating_b1 = SelfGating(num_outputs_1_0b)
self.gating_b2 = SelfGating(num_outputs_2_0b)
self.gating_b3 = SelfGating(num_outputs_3_0b)
@overrides(check_signature=False)
def forward(self, input_: torch.Tensor) -> torch.Tensor:
b0 = self.conv_b0(input_)
b1 = self.conv_b1_a(input_)
b1 = self.conv_b1_b(b1)
b2 = self.conv_b2_a(input_)
b2 = self.conv_b2_b(b2)
b3 = self.maxpool_b3(input_)
b3 = self.conv_b3_b(b3)
if self.gating:
b0 = self.gating_b0(b0)
b1 = self.gating_b1(b1)
b2 = self.gating_b2(b2)
b3 = self.gating_b3(b3)
return torch.cat((b0, b1, b2, b3), dim=1)
class SelfGating(nn.Module):
"""Feature gating as used in S3D-G. """
def __init__(self, input_dim: int) -> None:
super().__init__()
self.fc = nn.Linear(input_dim, input_dim)
self.sigmoid = nn.modules.activation.Sigmoid()
@overrides(check_signature=False)
def forward(self, input_: torch.Tensor) -> torch.Tensor:
spatiotemporal_average = input_.mean(dim=[2, 3, 4])
weights = self.fc(spatiotemporal_average)
weights = self.sigmoid(weights)
return weights[:, :, None, None, None] * input_
def _size3_to_spatial_temporal(size: _size_3_t, fill_value: int) -> Tuple[_size_3_t, _size_3_t]:
size = nn.modules.conv._triple(size)
return (fill_value, size[1], size[2]), (size[0], fill_value, fill_value)
class STConv3D(nn.Module):
def __init__(self, input_dim: int, output_dim: int, kernel_size: _size_3_t, stride: _size_3_t = 1,
padding: _size_3_t = 0, separable: bool = False) -> None:
super().__init__()
self.separable = separable
self.relu = nn.ReLU(inplace=True)
if separable:
assert (isinstance(kernel_size, int) and kernel_size != 1) or kernel_size[0] != 1
spatial_kernel_size, temporal_kernel_size = _size3_to_spatial_temporal(kernel_size, fill_value=1)
spatial_stride, temporal_stride = _size3_to_spatial_temporal(stride, fill_value=1)
spatial_padding, temporal_padding = _size3_to_spatial_temporal(padding, fill_value=0)
self.conv1 = nn.Conv3d(input_dim, output_dim, kernel_size=spatial_kernel_size, stride=spatial_stride,
padding=spatial_padding, bias=False)
self.conv2 = nn.Conv3d(output_dim, output_dim, kernel_size=temporal_kernel_size, stride=temporal_stride,
padding=temporal_padding, bias=False)
self.bn2 = nn.BatchNorm3d(output_dim)
else:
self.conv1 = nn.Conv3d(input_dim, output_dim, kernel_size=kernel_size, stride=stride, # noqa
padding=padding, bias=False)
self.bn1 = nn.BatchNorm3d(output_dim)
@overrides(check_signature=False)
def forward(self, input_: torch.Tensor) -> torch.Tensor:
out = self.relu(self.bn1(self.conv1(input_)))
if self.separable:
out = self.relu(self.bn2(self.conv2(out)))
return out
def _pad_top_bottom(kernel_dim: int, stride_val: int) -> Tuple[int, int]:
pad_along = max(kernel_dim - stride_val, 0)
pad_top_ = pad_along // 2
pad_bottom_ = pad_along - pad_top_
return pad_top_, pad_bottom_
def _get_padding_shape(kernel_size: _size_3_t, stride: _size_3_t) -> _size_6_t:
kernel_size = nn.modules.conv._triple(kernel_size)
stride = nn.modules.conv._triple(stride)
padding_shape = [padding_value
for pair in zip(kernel_size, stride)
for padding_value in _pad_top_bottom(*pair)]
depth_top = padding_shape.pop(0)
depth_bottom = padding_shape.pop(0)
padding_shape.append(depth_top)
padding_shape.append(depth_bottom)
return tuple(padding_shape)
class MaxPool3dTFPadding(torch.nn.Module):
def __init__(self, kernel_size: _size_3_t, stride: _size_3_t, padding: Literal["SAME"] = "SAME") -> None:
super().__init__()
if padding == "SAME":
self.padding_shape = _get_padding_shape(kernel_size, stride)
self.pad = torch.nn.ConstantPad3d(self.padding_shape, 0)
else:
raise ValueError(f"Padding strategy not supported: {padding}")
self.pool = torch.nn.MaxPool3d(kernel_size, stride, ceil_mode=True)
@overrides(check_signature=False)
def forward(self, input_: torch.Tensor) -> torch.Tensor:
input_ = self.pad(input_)
return self.pool(input_)
class S3DG(nn.Module):
def __init__(self, embedding_size: int = 512, space_to_depth: bool = True,
init: Literal["default", "kaiming_normal"] = "default", use_last_layer: bool = True) -> None:
super().__init__()
self.use_last_layer = use_last_layer
self.space_to_depth = space_to_depth
if space_to_depth:
self.conv1 = STConv3D(24, 64, kernel_size=(2, 4, 4), stride=1, padding=(1, 2, 2), separable=False) # noqa
else:
self.conv1 = STConv3D(3, 64, kernel_size=(3, 7, 7), stride=2, padding=(1, 3, 3), separable=False) # noqa
self.conv_2b = STConv3D(64, 64, kernel_size=1, separable=False)
self.conv_2c = STConv3D(64, 192, kernel_size=3, padding=1, separable=True)
self.gating = SelfGating(192)
self.maxpool_2a = MaxPool3dTFPadding(kernel_size=(1, 3, 3), stride=(1, 2, 2))
self.maxpool_3a = MaxPool3dTFPadding(kernel_size=(1, 3, 3), stride=(1, 2, 2))
self.mixed_3b = InceptionBlock(192, 64, 96, 128, 16, 32, 32)
self.mixed_3c = InceptionBlock(self.mixed_3b.output_dim, 128, 128, 192, 32, 96, 64)
self.maxpool_4a = MaxPool3dTFPadding(kernel_size=3, stride=2)
self.mixed_4b = InceptionBlock(self.mixed_3c.output_dim, 192, 96, 208, 16, 48, 64)
self.mixed_4c = InceptionBlock(self.mixed_4b.output_dim, 160, 112, 224, 24, 64, 64)
self.mixed_4d = InceptionBlock(self.mixed_4c.output_dim, 128, 128, 256, 24, 64, 64)
self.mixed_4e = InceptionBlock(self.mixed_4d.output_dim, 112, 144, 288, 32, 64, 64)
self.mixed_4f = InceptionBlock(self.mixed_4e.output_dim, 256, 160, 320, 32, 128, 128)
self.maxpool_5a = self.maxPool3d_5a_2x2 = MaxPool3dTFPadding(kernel_size=2, stride=2)
self.mixed_5b = InceptionBlock(self.mixed_4f.output_dim, 256, 160, 320, 32, 128, 128)
self.mixed_5c = InceptionBlock(self.mixed_5b.output_dim, 384, 192, 384, 48, 128, 128)
self.fc = nn.Linear(self.mixed_5c.output_dim, embedding_size)
if init == "kaiming_normal":
for m in self.modules():
if isinstance(m, nn.Conv3d):
nn.init.kaiming_normal_(m.weight, mode="fan_in", nonlinearity="relu")
elif isinstance(m, nn.BatchNorm3d):
nn.init.constant_(m.weight, 1)
nn.init.constant_(m.bias, 0)
@property
def output_size(self) -> int:
return self.fc.out_features if self.use_last_layer else self.mixed_5c.output_dim
@staticmethod
def _space_to_depth(input_: torch.Tensor) -> torch.Tensor:
B, C, T, H, W = input_.shape
input_ = input_.view(B, C, T // 2, 2, H // 2, 2, W // 2, 2)
input_ = input_.permute(0, 3, 5, 7, 1, 2, 4, 6)
input_ = input_.contiguous().view(B, 8 * C, T // 2, H // 2, W // 2)
return input_
@overrides(check_signature=False)
def forward(self, input_: torch.Tensor) -> torch.Tensor:
if self.space_to_depth:
input_ = self._space_to_depth(input_)
net = self.conv1(input_)
if self.space_to_depth:
net = net[:, :, 1:, 1:, 1:]
net = self.maxpool_2a(net)
net = self.conv_2b(net)
net = self.conv_2c(net)
if self.gating:
net = self.gating(net)
net = self.maxpool_3a(net)
net = self.mixed_3b(net)
net = self.mixed_3c(net)
net = self.maxpool_4a(net)
net = self.mixed_4b(net)
net = self.mixed_4c(net)
net = self.mixed_4d(net)
net = self.mixed_4e(net)
net = self.mixed_4f(net)
net = self.maxpool_5a(net)
net = self.mixed_5b(net)
net = self.mixed_5c(net)
net = torch.mean(net, dim=(2, 3, 4))
if self.use_last_layer:
return self.fc(net)
else:
return net
| 9,814 | 43.817352 | 118 | py |
fitclip | fitclip-main/aligner/encoder/frozen_in_time.py | # Originally from https://github.com/m-bain/frozen-in-time/blob/ba54e43/model/model.py
import logging
import sys
from typing import Any, Dict, Literal, Mapping, MutableMapping, Optional, Tuple, Union
import numpy as np
import timm
import torch
import torch.nn as nn
import torch.nn.functional as F
from cached_path import TYPE_PATH, cached_path
from transformers import AutoModel
from aligner.encoder import frozen_in_time_stub
from aligner.encoder.video_transformer import SpaceTimeTransformer
LOGGER = logging.getLogger(__name__)
STATE_DICT_MODULE_KEY = "module."
def state_dict_data_parallel_fix(load_state_dict: MutableMapping[str, Any],
curr_state_dict: MutableMapping[str, Any]) -> MutableMapping[str, Any]:
first_load_key = next(iter(load_state_dict.keys()))
first_curr_key = next(iter(curr_state_dict.keys()))
if not first_curr_key.startswith(STATE_DICT_MODULE_KEY) and first_load_key.startswith(STATE_DICT_MODULE_KEY):
return {k[len(STATE_DICT_MODULE_KEY):]: v for k, v in load_state_dict.items()}
elif first_curr_key.startswith(STATE_DICT_MODULE_KEY) and not first_load_key.startswith(STATE_DICT_MODULE_KEY):
return {STATE_DICT_MODULE_KEY + k: v for k, v in load_state_dict.items()}
else:
return load_state_dict
class BaseModel(nn.Module):
"""Base class for all models"""
def __str__(self) -> str:
return f"{super().__str__()}\n" \
f"Trainable parameters: {sum(np.prod(p.size()) for p in self.parameters() if p.requires_grad)}"
class FrozenInTime(BaseModel):
def __init__(self, video_params: Dict[str, Any], text_params: Dict[str, Any], projection_dim: int = 256,
load_checkpoint: Optional[TYPE_PATH] = None, projection: Literal["", "minimal"] = "minimal",
load_temporal_fix: Literal["zeros", "interp", "bilinear"] = "zeros") -> None:
super().__init__()
self.video_params = video_params
self.text_params = text_params
self.load_temporal_fix = load_temporal_fix
if not text_params["pretrained"]:
raise ValueError("HuggingFace text models require `pretrained` init.")
transformers_modeling_utils_logger = logging.getLogger("transformers.modeling_utils")
transformers_modeling_utils_logger.disabled = True
self.text_model = AutoModel.from_pretrained(text_params["model"])
transformers_modeling_utils_logger.disabled = False
pretrained = video_params["pretrained"]
if video_params["model"] == "SpaceTimeTransformer":
num_frames = video_params.get("num_frames", 4)
time_init = video_params.get("time_init", "zeros")
attention_style = video_params.get("attention_style", "frozen-in-time")
arch_config = video_params.get("arch_config", "base_patch16_224")
if arch_config == "base_patch16_224":
vit_model = timm.models.vision_transformer.vit_base_patch16_224(pretrained=pretrained)
model = SpaceTimeTransformer(num_frames=num_frames, time_init=time_init,
attention_style=attention_style)
else:
raise ValueError(f"Unrecognized arch_config: {arch_config}")
model.head = nn.Identity()
model.pre_logits = nn.Identity()
ftr_dim = model.embed_dim
if not load_checkpoint:
vit_checkpoint = vit_model.state_dict()
model.load_state_dict(vit_checkpoint, strict=False)
self.video_model = model
else:
raise ValueError(f"{video_params['model']} not supported")
# for backwards compatibility (old models)
self.video_model.fc = nn.Identity()
# Project to a common embedding
if projection == "minimal":
txt_proj = nn.Sequential(nn.ReLU(), nn.Linear(self.text_model.config.hidden_size, projection_dim))
vid_proj = nn.Sequential(nn.Linear(ftr_dim, projection_dim))
elif projection == "":
txt_proj = nn.Identity()
vid_proj = nn.Identity()
else:
raise ValueError(f"Unrecognized projection: {projection}")
self.txt_proj = txt_proj
self.vid_proj = vid_proj
if load_checkpoint:
load_checkpoint = cached_path(load_checkpoint)
# To make pickle work with a missing module and class. See https://stackoverflow.com/a/2121918/1165181
sys.modules["parse_config"] = frozen_in_time_stub
LOGGER.info("Loading frozen-in-time checkpoint…")
# `map_location="cpu"` to avoid bloating GPU=0 with each process' copy of it.
checkpoint = torch.load(load_checkpoint, map_location="cpu")
del sys.modules["parse_config"]
state_dict = checkpoint["state_dict"]
new_state_dict = state_dict_data_parallel_fix(state_dict, self.state_dict())
new_state_dict = self._inflate_positional_embeds(new_state_dict)
self.load_state_dict(new_state_dict, strict=True) # noqa
LOGGER.info("Checkpoint loaded.")
def forward(self, data: Mapping[str, Any], return_embeds: bool = True) -> Union[torch.Tensor,
Tuple[torch.Tensor, torch.Tensor]]:
text_data = data["text"]
video_data = data["video"]
text_embeddings = self.compute_text(text_data)
video_embeddings = self.compute_video(video_data)
if return_embeds:
return text_embeddings, video_embeddings
return sim_matrix(text_embeddings, video_embeddings)
def compute_text(self, text_data: Mapping[str, Any]) -> torch.Tensor:
if self.text_params["model"].startswith("bert"):
text_embeddings = self.text_model(text_data["input_ids"], attention_mask=text_data["attention_mask"])[
"pooler_output"]
elif self.text_params["model"].startswith("distilbert"):
text_embeddings = self.text_model(**text_data).last_hidden_state[:, 0, :]
else:
raise ValueError(f"Unrecognized text model: {self.text_params['model']}")
return self.txt_proj(text_embeddings)
def compute_video(self, video_data: Mapping[str, Any]) -> torch.Tensor:
video_embeddings = self.video_model(video_data)
return self.vid_proj(video_embeddings)
def _inflate_positional_embeds(self, new_state_dict: MutableMapping[str, Any]) -> Mapping[str, Any]:
# allow loading of timesformer with fewer num_frames
curr_keys = set(self.state_dict().keys())
if "video_model.temporal_embed" in new_state_dict and "video_model.temporal_embed" in curr_keys:
load_temporal_embed = new_state_dict["video_model.temporal_embed"]
load_num_frames = load_temporal_embed.shape[1]
curr_num_frames = self.video_params["num_frames"]
embed_dim = load_temporal_embed.shape[2]
if load_num_frames != curr_num_frames:
if load_num_frames > curr_num_frames:
LOGGER.warning(f"The loaded {self.video_params['model']} model has MORE frames than the current "
f"one. Loading weights, filling in the extras via {self.load_temporal_fix}")
new_temporal_embed = load_temporal_embed[:, :curr_num_frames, :]
else:
LOGGER.warning(f"The loaded {self.video_params['model']} model has FEWER frames than the current "
f"one. Loading weights, filling in the extras via {self.load_temporal_fix}")
if self.load_temporal_fix == "zeros":
new_temporal_embed = torch.zeros([load_temporal_embed.shape[0], curr_num_frames, embed_dim])
new_temporal_embed[:, :load_num_frames] = load_temporal_embed
elif self.load_temporal_fix in ["interp", "bilinear"]:
# interpolate
# unsqueeze so pytorch thinks it's an image
mode = "nearest"
if self.load_temporal_fix == "bilinear":
mode = "bilinear"
load_temporal_embed = load_temporal_embed.unsqueeze(0)
new_temporal_embed = F.interpolate(load_temporal_embed,
(curr_num_frames, embed_dim), mode=mode).squeeze(0)
else:
raise ValueError(f"Unrecognized load_temporal_fix: {self.load_temporal_fix}")
new_state_dict["video_model.temporal_embed"] = new_temporal_embed
# allow loading with smaller spatial patches. assumes custom border crop, to append the
# border patches to the input sequence
if "video_model.pos_embed" in new_state_dict and "video_model.pos_embed" in curr_keys:
load_pos_embed = new_state_dict["video_model.pos_embed"]
load_num_patches = load_pos_embed.shape[1]
curr_pos_embed = self.state_dict()["video_model.pos_embed"]
if load_num_patches != curr_pos_embed.shape[1]:
raise ValueError(
"Loading models with different spatial resolution / patch number not yet implemented, sorry.")
return new_state_dict
def sim_matrix(a: torch.Tensor, b: torch.Tensor, eps: float = 1e-8) -> torch:
a_n, b_n = a.norm(dim=1)[:, None], b.norm(dim=1)[:, None]
a_norm = a / torch.max(a_n, eps * torch.ones_like(a_n)) # noqa
b_norm = b / torch.max(b_n, eps * torch.ones_like(b_n)) # noqa
return torch.mm(a_norm, b_norm.transpose(0, 1))
| 9,799 | 49.515464 | 119 | py |
fitclip | fitclip-main/aligner/encoder/frozen_in_time_video_text_encoder.py | import os
from typing import Iterable, Iterator
import torch
from overrides import overrides
from torchvision import transforms as T
from transformers import AutoTokenizer
from aligner.data.frame_sampler import FrameSampler, RandomFromUniformIntervalsFrameSampler, UniformFrameSampler
from aligner.encoder.frozen_in_time import FrozenInTime
from aligner.encoder.video_encoder import TYPE_TRANSFORM, TYPE_VIDEO_INPUT, float_standard_denormalize
from aligner.encoder.video_text_encoder import TYPE_TEXT_INPUT, TYPE_TOKENIZER, VideoTextEncoder
from aligner.transforms import ConvertBHWCtoBCHW, RandomResizedCropWithRandomInterpolation
def _normalize(t: torch.Tensor, eps: float = 1e-8) -> torch.Tensor:
return t / torch.max(t.norm(dim=1, keepdim=True), eps * torch.ones_like(t)) # noqa
class FrozenInTimeVideoTextEncoder(VideoTextEncoder):
# FIXME: set the max tokens by default as in CLIP, also to avoid spending too much memory when using prompts.
def __init__(self, model: FrozenInTime, image_size: int = 224, num_frames: int = 4, max_tokens: int = 77) -> None:
super().__init__()
self.model = model
os.environ["TOKENIZERS_PARALLELISM"] = "0"
self.tokenizer = AutoTokenizer.from_pretrained(model.text_params["model"])
self.normalize = T.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225))
self.image_size = image_size
self.num_frames = num_frames
self.max_tokens = max_tokens
@overrides(check_signature=False)
def encode_video(self, video: TYPE_VIDEO_INPUT, eps: float = 1e-8) -> torch.Tensor:
return _normalize(self.model.compute_video(video), eps=eps)
@overrides(check_signature=False)
def encode_text(self, text: TYPE_TEXT_INPUT, eps: float = 1e-8) -> torch.Tensor:
return _normalize(self.model.compute_text(text), eps=eps)
def _tokenize(self, texts: Iterable[str]) -> TYPE_TEXT_INPUT:
texts = texts if isinstance(texts, (list, tuple)) else list(texts)
return self.tokenizer(texts, return_tensors="pt", padding=True, truncation=True, max_length=self.max_tokens)
@overrides
def get_tokenizer(self) -> TYPE_TOKENIZER:
return self._tokenize
@overrides
def decode_text(self, text: TYPE_TEXT_INPUT) -> Iterator[str]:
return self.tokenizer.batch_decode(text["input_ids"], skip_special_tokens=True)
@overrides
def get_train_frame_sampler(self) -> FrameSampler:
return RandomFromUniformIntervalsFrameSampler(self.num_frames)
@overrides
def get_eval_frame_sampler(self) -> FrameSampler:
return UniformFrameSampler(self.num_frames)
@overrides
def get_train_transform(self, dtype: torch.dtype) -> TYPE_TRANSFORM:
return T.Compose([
ConvertBHWCtoBCHW(),
T.ConvertImageDtype(dtype),
RandomResizedCropWithRandomInterpolation(self.image_size, scale=(0.5, 1.0)),
T.RandomHorizontalFlip(),
self.normalize,
])
@overrides
def get_eval_transform(self, dtype: torch.dtype) -> TYPE_TRANSFORM:
return T.Compose([
ConvertBHWCtoBCHW(),
T.ConvertImageDtype(dtype),
T.Resize(self.image_size),
T.CenterCrop(self.image_size),
self.normalize,
])
@property
@overrides
def should_pad_batch(self) -> bool:
return True
@overrides
def to_bchw(self, t: torch.Tensor) -> torch.Tensor:
return t
@overrides
def denormalize_video_tensor(self, video: TYPE_VIDEO_INPUT) -> torch.Tensor:
return float_standard_denormalize(video, mean=self.normalize.mean, std=self.normalize.std)
| 3,686 | 37.810526 | 118 | py |
fitclip | fitclip-main/aligner/encoder/videoclip.py | import torch
import torch.utils.checkpoint
from torch import nn
from transformers import AutoConfig, BertModel, BertPreTrainedModel
from transformers.activations import ACT2FN
from transformers.models.bert.modeling_bert import BertEmbeddings, BertEncoder
class VideoTokenMLP(nn.Module):
def __init__(self, config):
super().__init__()
input_dim = config.input_dim if hasattr(config, "input_dim") else 512
self.linear1 = nn.Linear(input_dim, config.hidden_size)
self.LayerNorm = nn.LayerNorm(config.hidden_size)
self.activation = ACT2FN[config.hidden_act]
self.linear2 = nn.Linear(config.hidden_size, config.hidden_size)
def forward(self, hidden_states):
hidden_states = self.linear1(hidden_states)
hidden_states = self.activation(hidden_states)
hidden_states = self.LayerNorm(hidden_states)
hidden_states = self.linear2(hidden_states)
return hidden_states
class MMBertEmbeddings(BertEmbeddings):
def __init__(self, config):
super().__init__(config)
self.max_video_len = config.max_video_len
if hasattr(config, "use_seg_emb") and config.use_seg_emb:
"""the original VLM paper uses seg_embeddings for temporal space.
although not used it changed the randomness of initialization.
we keep it for reproducibility.
"""
self.seg_embeddings = nn.Embedding(256, config.hidden_size)
def forward( # noqa
self,
input_ids,
input_video_embeds,
token_type_ids=None,
position_ids=None,
inputs_embeds=None,
):
input_tensor = input_ids if input_ids is not None else inputs_embeds
if input_video_embeds is not None:
input_shape = (
input_tensor.size(0),
input_tensor.size(1) + input_video_embeds.size(1),
)
else:
input_shape = (input_tensor.size(0), input_tensor.size(1))
if position_ids is None:
"""
Auto skip position embeddings for text only case.
use cases:
(1) action localization and segmentation:
feed in len-1 dummy video token needs text part to
skip input_video_embeds.size(1) for the right
position_ids for video [SEP] and rest text tokens.
(2) MMFusionShare for two forward passes:
in `forward_text`: input_video_embeds is None.
need to skip video [SEP] token.
# video_len + 1: [CLS] + video_embed
# self.max_video_len + 1: [SEP] for video.
# self.max_video_len + 2: [SEP] for video.
# self.max_video_len + input_ids.size(1): rest for text.
"""
if input_video_embeds is not None:
video_len = input_video_embeds.size(1)
starting_offset = self.max_video_len + 1 # video [SEP]
ending_offset = self.max_video_len + input_ids.size(1)
else:
video_len = 0
starting_offset = self.max_video_len + 2 # first text token.
ending_offset = self.max_video_len + input_ids.size(1) + 1
position_ids = torch.cat([
self.position_ids[:, :video_len + 1],
self.position_ids[:, starting_offset:ending_offset]
], dim=1)
if token_type_ids is None:
token_type_ids = torch.zeros(
input_shape, dtype=torch.long, device=self.position_ids.device
)
"""
the format of input_ids is [CLS] [SEP] caption [SEP] padding.
the goal is to build [CLS] video tokens [SEP] caption [SEP] .
"""
if inputs_embeds is None:
inputs_embeds = self.word_embeddings(input_ids)
if input_video_embeds is not None:
inputs_mm_embeds = torch.cat([
inputs_embeds[:, :1], input_video_embeds, inputs_embeds[:, 1:]
], dim=1)
else:
# text only for `MMFusionShare`.
inputs_mm_embeds = inputs_embeds
position_embeddings = self.position_embeddings(position_ids)
token_type_embeddings = self.token_type_embeddings(token_type_ids)
embeddings = inputs_mm_embeds + position_embeddings
embeddings += token_type_embeddings
embeddings = self.LayerNorm(embeddings)
embeddings = self.dropout(embeddings)
return embeddings
class MultiLayerAttentionMaskBertEncoder(BertEncoder):
"""extend BertEncoder with the capability of
multiple layers of attention mask."""
def forward( # noqa
self,
hidden_states,
attention_mask=None,
head_mask=None,
encoder_hidden_states=None,
encoder_attention_mask=None,
output_attentions=False,
output_hidden_states=False,
return_dict=False,
):
all_hidden_states = () if output_hidden_states else None
all_attentions = () if output_attentions else None
for i, layer_module in enumerate(self.layer):
if output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
layer_head_mask = head_mask[i] if head_mask is not None else None
layer_attention_mask = (
attention_mask[:, i, :, :, :]
if attention_mask.dim() == 5
else attention_mask
)
if getattr(self.config, "gradient_checkpointing", False):
def create_custom_forward(module):
def custom_forward(*inputs):
return module(*inputs, output_attentions)
return custom_forward
layer_outputs = torch.utils.checkpoint.checkpoint(
create_custom_forward(layer_module),
hidden_states,
layer_attention_mask,
layer_head_mask,
encoder_hidden_states,
encoder_attention_mask,
)
else:
layer_outputs = layer_module(
hidden_states,
layer_attention_mask,
layer_head_mask,
encoder_hidden_states,
encoder_attention_mask,
output_attentions,
)
hidden_states = layer_outputs[0]
if output_attentions:
all_attentions = all_attentions + (layer_outputs[1],)
if output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
return tuple(
v
for v in [hidden_states, all_hidden_states, all_attentions]
if v is not None
)
class MMBertModel(BertModel):
"""MMBertModel has MMBertEmbedding to support video tokens."""
def __init__(self, config, add_pooling_layer=True): # noqa
super().__init__(config)
# overwrite embedding
self.embeddings = MMBertEmbeddings(config)
self.encoder = MultiLayerAttentionMaskBertEncoder(config)
self.init_weights() # noqa
def forward(
self,
input_ids=None,
input_video_embeds=None,
attention_mask=None,
token_type_ids=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
encoder_hidden_states=None,
encoder_attention_mask=None,
output_attentions=None,
output_hidden_states=None,
return_dict=None,
separate_forward_split=None,
):
output_attentions = (
output_attentions
if output_attentions is not None
else self.config.output_attentions # noqa
)
output_hidden_states = (
output_hidden_states
if output_hidden_states is not None
else self.config.output_hidden_states # noqa
)
return_dict = (
return_dict if return_dict is not None
else self.config.use_return_dict # noqa
)
if input_ids is not None and inputs_embeds is not None:
raise ValueError(
"You cannot specify both input_ids "
"and inputs_embeds at the same time"
)
elif input_ids is not None:
if input_video_embeds is not None:
input_shape = (
input_ids.size(0),
input_ids.size(1) + input_video_embeds.size(1),
)
else:
input_shape = (
input_ids.size(0),
input_ids.size(1),
)
elif inputs_embeds is not None:
if input_video_embeds is not None:
input_shape = (
inputs_embeds.size(0),
inputs_embeds.size(1) + input_video_embeds.size(1),
)
else:
input_shape = (
input_ids.size(0),
input_ids.size(1),
)
else:
raise ValueError(
"You have to specify either input_ids or inputs_embeds")
device = (inputs_embeds if input_ids is None else input_ids).device
if attention_mask is None:
attention_mask = torch.ones(input_shape, device=device)
if token_type_ids is None:
token_type_ids = torch.zeros(input_shape, dtype=torch.long, device=device)
# We can provide a self-attention mask of dimensions
# [batch_size, from_seq_length, to_seq_length]
# ourselves in which case
# we just need to make it broadcastable to all heads.
extended_attention_mask: torch.Tensor = \
self.get_extended_attention_mask(
attention_mask, input_shape, device)
# If a 2D or 3D attention mask is provided for the cross-attention
# we need to make broadcastable to
# [batch_size, num_heads, seq_length, seq_length]
if self.config.is_decoder and encoder_hidden_states is not None: # noqa
(
encoder_batch_size,
encoder_sequence_length,
_,
) = encoder_hidden_states.size()
encoder_hidden_shape = (
encoder_batch_size, encoder_sequence_length)
if encoder_attention_mask is None:
encoder_attention_mask = torch.ones(
encoder_hidden_shape, device=device)
encoder_extended_attention_mask = self.invert_attention_mask( # noqa
encoder_attention_mask
)
else:
encoder_extended_attention_mask = None
# Prepare head mask if needed
# 1.0 in head_mask indicate we keep the head
# attention_probs has shape bsz x n_heads x N x N
# input head_mask has shape [num_heads] or
# [num_hidden_layers x num_heads]
# and head_mask is converted to shape
# [num_hidden_layers x batch x num_heads x seq_length x seq_length]
head_mask = self.get_head_mask( # noqa
head_mask, self.config.num_hidden_layers) # noqa
embedding_output = self.embeddings(
input_ids,
input_video_embeds,
position_ids=position_ids,
token_type_ids=token_type_ids,
inputs_embeds=inputs_embeds,
)
if separate_forward_split is not None:
split_embedding_output = \
embedding_output[:, :separate_forward_split]
split_extended_attention_mask = extended_attention_mask[
:, :, :, :separate_forward_split, :separate_forward_split
]
split_encoder_outputs = self.encoder(
split_embedding_output,
attention_mask=split_extended_attention_mask,
head_mask=head_mask,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_extended_attention_mask,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
assert (
len(split_encoder_outputs) <= 2
), "we do not support merge on attention for now."
encoder_outputs = [[split_encoder_outputs[0]]]
if len(split_encoder_outputs) == 2:
encoder_outputs.append([])
for _all_hidden_states in split_encoder_outputs[1]:
encoder_outputs[-1].append([_all_hidden_states])
split_embedding_output = \
embedding_output[:, separate_forward_split:]
split_extended_attention_mask = extended_attention_mask[
:, :, :, separate_forward_split:, separate_forward_split:
]
split_encoder_outputs = self.encoder(
split_embedding_output,
attention_mask=split_extended_attention_mask,
head_mask=head_mask,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_extended_attention_mask,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
assert len(split_encoder_outputs) <= 2, "we do not support merge on attention for now."
encoder_outputs[0].append(split_encoder_outputs[0])
encoder_outputs[0] = torch.cat(encoder_outputs[0], dim=1)
if len(split_encoder_outputs) == 2:
for layer_idx, _all_hidden_states in enumerate(
split_encoder_outputs[1]
):
encoder_outputs[1][layer_idx].append(_all_hidden_states)
encoder_outputs[1][layer_idx] = torch.cat(
encoder_outputs[1][layer_idx], dim=1
)
encoder_outputs = tuple(encoder_outputs)
else:
encoder_outputs = self.encoder(
embedding_output,
attention_mask=extended_attention_mask,
head_mask=head_mask,
encoder_hidden_states=encoder_hidden_states,
encoder_attention_mask=encoder_extended_attention_mask,
output_attentions=output_attentions,
output_hidden_states=output_hidden_states,
return_dict=return_dict,
)
sequence_output = encoder_outputs[0]
pooled_output = None if self.pooler is None else self.pooler(sequence_output) # noqa
return (sequence_output, pooled_output) + encoder_outputs[1:]
def get_extended_attention_mask(self, attention_mask, input_shape, device):
"""This is borrowed from `modeling_utils.py` with the support of
multi-layer attention masks.
The second dim is expected to be number of layers.
See `MMAttentionMaskProcessor`.
Makes broadcastable attention and causal masks so that future
and masked tokens are ignored.
Arguments:
attention_mask (:obj:`torch.Tensor`):
Mask with ones indicating tokens to attend to,
zeros for tokens to ignore.
input_shape (:obj:`Tuple[int]`):
The shape of the input to the model.
device: (:obj:`torch.device`):
The device of the input to the model.
Returns:
:obj:`torch.Tensor` The extended attention mask, with the same dtype as :obj:`attention_mask.dtype`.
"""
# We can provide a self-attention mask of dimensions [batch_size, from_seq_length, to_seq_length] ourselves
# in which case we just need to make it broadcastable to all heads.
if attention_mask.dim() == 4:
extended_attention_mask = attention_mask[:, :, None, :, :]
extended_attention_mask = extended_attention_mask.to(dtype=self.dtype) # noqa; fp16 compatibility
extended_attention_mask = (1.0 - extended_attention_mask) * -10000.0
return extended_attention_mask
else:
return super().get_extended_attention_mask(attention_mask, input_shape, device) # noqa
class MMBertForEncoder(BertPreTrainedModel):
"""A BertModel for Contrastive Learning."""
def __init__(self, config):
super().__init__(config)
self.videomlp = VideoTokenMLP(config)
self.bert = MMBertModel(config)
self.init_weights() # noqa
def forward(
self,
input_ids=None,
input_video_embeds=None,
attention_mask=None,
token_type_ids=None,
position_ids=None,
head_mask=None,
inputs_embeds=None,
output_attentions=None,
output_hidden_states=None,
return_dict=None,
):
return_dict = self.config.use_return_dict if return_dict is None else return_dict # noqa
video_tokens = None if input_video_embeds is None else self.videomlp(input_video_embeds)
return self.bert(input_ids, video_tokens, attention_mask=attention_mask, token_type_ids=token_type_ids, # noqa
position_ids=position_ids, head_mask=head_mask, inputs_embeds=inputs_embeds,
output_attentions=output_attentions, output_hidden_states=output_hidden_states,
return_dict=return_dict)
class MMFusion(nn.Module):
"""a MMPT wrapper class for MMBert style models.
TODO: move isolated mask to a subclass.
"""
def __init__(self, max_video_len: int = 32, last_iso_layer: int = 12, num_hidden_video_layers: int = 6):
super().__init__()
self.model_name = "bert-base-uncased"
transformer_config = AutoConfig.from_pretrained(self.model_name)
self.hidden_size = transformer_config.hidden_size
self.is_train = False
# 0 means no iso; 1-12 means iso up to that layer.
self.num_hidden_layers = transformer_config.num_hidden_layers
self.last_iso_layer = last_iso_layer
model_config = AutoConfig.from_pretrained(self.model_name)
model_config.max_video_len = max_video_len
# TODO: make each model a set of config class.
if hasattr(model_config, "num_layers"):
model_config.num_layers = num_hidden_video_layers
else:
model_config.num_hidden_layers = num_hidden_video_layers
self.video_encoder = MMBertForEncoder.from_pretrained(self.model_name, config=model_config)
# exact same NLP model from HuggingFace transformer.
self.text_encoder = AutoConfig.from_pretrained("bert-base-uncased")
def forward(
self,
caps,
cmasks,
vfeats,
vmasks,
**kwargs
):
raise NotImplementedError(
"Please derive MMFusion module."
)
def _mm_on_the_fly(
self,
cmasks,
vmasks,
attention_mask
):
"""helper function for mask, seg_ids and token_type_ids."""
if attention_mask is None:
attention_mask = self._mm_attention_mask(cmasks, vmasks)
"""
0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1
| first sequence | second sequence |
"""
token_type_ids = torch.cat([
torch.zeros((vmasks.size(0), vmasks.size(1) + 2), dtype=torch.long, device=vmasks.device),
torch.ones((cmasks.size(0), cmasks.size(1) - 2), dtype=torch.long, device=cmasks.device)], dim=1)
return attention_mask, token_type_ids
def _mm_attention_mask(self, cmasks, vmasks):
assert cmasks.size(0) == vmasks.size(0), "{}, {}, {}, {}".format(
str(cmasks.size()),
str(vmasks.size()),
str(cmasks.size(0)),
str(vmasks.size(0)),
)
mm_mask = torch.cat([cmasks[:, :1], vmasks, cmasks[:, 1:]], dim=1)
if self.last_iso_layer == 0:
# hard attention mask.
return mm_mask
else:
# a gpu iso mask; 0 : num_iso_layer is isolated;
# num_iso_layer: are MM-fused.
# make an iso layer
batch_size = cmasks.size(0)
iso_mask = self._make_iso_mask(batch_size, cmasks, vmasks)
mm_mask = mm_mask[:, None, :].repeat(1, mm_mask.size(-1), 1)
iso_mm_masks = []
# hard attention mask.
iso_mask = iso_mask[:, None, :, :].repeat(1, self.last_iso_layer, 1, 1)
iso_mm_masks.append(iso_mask)
if self.last_iso_layer < self.num_hidden_layers:
mm_mask = mm_mask[:, None, :, :].repeat(1, self.num_hidden_layers - self.last_iso_layer, 1, 1)
iso_mm_masks.append(mm_mask)
iso_mm_masks = torch.cat(iso_mm_masks, dim=1)
return iso_mm_masks
def _make_iso_mask(self, batch_size, cmasks, vmasks): # noqa
cls_self_mask = torch.cat(
[
torch.ones(
(batch_size, 1), dtype=torch.bool, device=cmasks.device),
torch.zeros(
(batch_size, cmasks.size(1) + vmasks.size(1) - 1),
dtype=torch.bool, device=cmasks.device)
], dim=1)
iso_video_mask = torch.cat(
[
# [CLS] is not used.
torch.zeros(
(batch_size, 1), dtype=torch.bool, device=cmasks.device
),
vmasks,
# assume to be 1.
cmasks[:, 1:2],
# 2 means [CLS] + [SEP]
torch.zeros(
(batch_size, cmasks.size(1) - 2),
dtype=torch.bool,
device=cmasks.device,
),
],
dim=1,
)
iso_text_mask = torch.cat(
[
torch.zeros(
(batch_size, 2 + vmasks.size(1)),
dtype=torch.bool,
device=cmasks.device,
), # [CLS] is not used.
cmasks[:, 2:], # assume to be 1.
],
dim=1,
)
cls_self_mask = cls_self_mask[:, None, :]
iso_video_mask = iso_video_mask[:, None, :].repeat(
1, vmasks.size(1) + 1, 1)
iso_text_mask = iso_text_mask[:, None, :].repeat(
1, cmasks.size(1) - 2, 1)
return torch.cat([cls_self_mask, iso_video_mask, iso_text_mask], dim=1)
def _pooling_vt_layer(
self,
layered_sequence_output,
cmasks,
vmasks
):
layer_idx = self.last_iso_layer \
if self.last_iso_layer > 0 else self.num_hidden_layers
hidden_state = layered_sequence_output[layer_idx]
# also output pooled_video and pooled_text.
batch_size = cmasks.size(0)
# pool the modality.
text_offset = vmasks.size(1) + 2 # [CLS] + [SEP]
# video tokens + [SEP]
video_outputs = hidden_state[:, 1:text_offset]
video_attention_mask = torch.cat(
[
vmasks,
torch.ones((batch_size, 1), dtype=torch.bool, device=vmasks.device),
],
dim=1,
)
assert video_outputs.size(1) == video_attention_mask.size(1)
pooled_video = (torch.sum(video_outputs * video_attention_mask.unsqueeze(-1), dim=1)
/ video_attention_mask.sum(1, keepdim=True))
# pooled_video = torch.mean(video_outputs[0], dim=1)
# text tokens + [SEP]
text_attention_mask = cmasks[:, 2:]
text_outputs = hidden_state[:, text_offset:]
assert text_outputs.size(1) == text_attention_mask.size(1)
pooled_text = torch.sum(
text_outputs * text_attention_mask.unsqueeze(-1), dim=1
) / text_attention_mask.sum(1, keepdim=True)
return pooled_video, pooled_text
class MMFusionSeparate(MMFusion):
def forward(
self,
caps,
cmasks,
vfeats,
vmasks,
attention_mask=None,
video_label=None,
text_label=None,
output_hidden_states=False,
**kwargs
):
pooled_video = self.forward_video(
vfeats,
vmasks,
caps,
cmasks,
output_hidden_states
)
pooled_text = self.forward_text(
caps,
cmasks,
output_hidden_states
)
return {"pooled_video": pooled_video, "pooled_text": pooled_text}
def forward_video(
self,
vfeats,
vmasks,
caps,
cmasks,
output_hidden_states=False,
**kwargs # noqa
):
input_ids = caps[:, :2]
attention_mask = torch.cat([cmasks[:, :1], vmasks, cmasks[:, 1:2]], dim=1)
token_type_ids = torch.zeros(
(vmasks.size(0), vmasks.size(1) + 2),
dtype=torch.long,
device=vmasks.device)
outputs = self.video_encoder(
input_ids=input_ids,
input_video_embeds=vfeats,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
output_hidden_states=True
)
video_outputs = outputs[0]
if output_hidden_states:
return video_outputs
batch_size = cmasks.size(0)
video_attention_mask = torch.cat([torch.zeros((batch_size, 1), dtype=torch.bool, device=vmasks.device),
vmasks, torch.ones((batch_size, 1), dtype=torch.bool, device=vmasks.device)],
dim=1)
assert video_outputs.size(1) == video_attention_mask.size(1)
video_attention_mask = video_attention_mask.type(video_outputs.dtype) / video_attention_mask.sum(1,
keepdim=True)
return torch.bmm(video_outputs.transpose(2, 1), video_attention_mask.unsqueeze(2)).squeeze(-1)
def forward_text(
self,
caps,
cmasks,
output_hidden_states=False,
**kwargs # noqa
):
input_ids = torch.cat([
caps[:, :1], caps[:, 2:],
], dim=1)
attention_mask = torch.cat([
cmasks[:, :1],
cmasks[:, 2:]
], dim=1)
# different from sharing, we use all-0 type.
token_type_ids = torch.zeros(
(cmasks.size(0), cmasks.size(1) - 1),
dtype=torch.long,
device=cmasks.device)
outputs = self.text_encoder(
input_ids=input_ids,
attention_mask=attention_mask,
token_type_ids=token_type_ids,
output_hidden_states=True
)
text_outputs = outputs[0]
if output_hidden_states:
return text_outputs
batch_size = caps.size(0)
# text tokens + [SEP]
text_attention_mask = torch.cat([torch.zeros((batch_size, 1), dtype=torch.bool, device=cmasks.device),
cmasks[:, 2:]], dim=1)
assert text_outputs.size(1) == text_attention_mask.size(1)
text_attention_mask = text_attention_mask.type(text_outputs.dtype) / text_attention_mask.sum(1, keepdim=True)
return torch.bmm(text_outputs.transpose(2, 1), text_attention_mask.unsqueeze(2)).squeeze(-1)
| 28,028 | 38.256303 | 119 | py |
fitclip | fitclip-main/aligner/encoder/video_transformer.py | # From https://github.com/m-bain/frozen-in-time/blob/ba54e43/model/video_transformer.py
"""
Implementations of Video Transformers in PyTorch
A PyTorch implementation of space-time transformer as described in
'Frozen in Time: A Joint Image and Video Encoder for End-to-End Retrieval' - https://arxiv.org/abs/2104.00650
A PyTorch implementation of timesformer as described in
'Is Space-Time Attention All You Need for Video Understanding?' - https://arxiv.org/abs/2102.05095
Acknowledgments:
- This code builds on Ross Wightman's vision_transformer code in pytorch-image-models:
https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py
- It is also inspired by lucidrains timesformer implementation:
https://github.com/lucidrains/TimeSformer-pytorch
Hacked together by Max Bain
"""
from collections import OrderedDict
from functools import partial
import torch
from einops import rearrange, repeat
from timm.models.layers import DropPath, to_2tuple, trunc_normal_
from torch import einsum, nn
def attn(q, k, v):
sim = einsum('b i d, b j d -> b i j', q, k)
attn = sim.softmax(dim=-1)
out = einsum('b i j, b j d -> b i d', attn, v)
return out
class Mlp(nn.Module):
def __init__(self, in_features, hidden_features=None, out_features=None, act_layer=nn.GELU, drop=0.):
super().__init__()
out_features = out_features or in_features
hidden_features = hidden_features or in_features
self.fc1 = nn.Linear(in_features, hidden_features)
self.act = act_layer()
self.fc2 = nn.Linear(hidden_features, out_features)
self.drop = nn.Dropout(drop)
def forward(self, x):
x = self.fc1(x)
x = self.act(x)
x = self.drop(x)
x = self.fc2(x)
x = self.drop(x)
return x
class VideoPatchEmbed(nn.Module):
""" Video to Patch Embedding
"""
def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768,
num_frames=8):
super().__init__()
img_size = to_2tuple(img_size)
patch_size = to_2tuple(patch_size)
num_patches = (img_size[1] // patch_size[1]) * (img_size[0] // patch_size[0]) * num_frames
self.img_size = img_size
self.patch_size = patch_size
self.num_patches = num_patches
self.num_frames = num_frames
self.embed_dim = embed_dim
self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)
def forward(self, x):
B, F, C, H, W = x.shape
assert F <= self.num_frames
x = x.view(-1, C, H, W)
x = self.proj(x)
return x
class VarAttention(nn.Module):
def __init__(self, dim, num_heads=8, qkv_bias=False, qk_scale=None, attn_drop=0., proj_drop=0.,
initialize='random'):
super().__init__()
self.num_heads = num_heads
head_dim = dim // num_heads
# NOTE scale factor was wrong in my original version, can set manually to be compat with prev weights
self.scale = qk_scale or head_dim ** -0.5
self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)
self.proj = nn.Linear(dim, dim)
if initialize == 'zeros':
self.qkv.weight.data.fill_(0)
self.qkv.bias.data.fill_(0)
# fill proj weight with 1 here to improve training dynamics. Otherwise temporal attention inputs
# are multiplied by 0*0, which is hard for the model to move out of.
self.proj.weight.data.fill_(1)
self.proj.bias.data.fill_(0)
self.attn_drop = nn.Dropout(attn_drop)
self.proj_drop = nn.Dropout(proj_drop)
def forward(self, x, einops_from, einops_to, **einops_dims):
h = self.num_heads
# project x to q, k, v values
q, k, v = self.qkv(x).chunk(3, dim=-1)
q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v))
q *= self.scale
# splice out CLS token at index 1
(cls_q, q_), (cls_k, k_), (cls_v, v_) = map(lambda t: (t[:, 0:1], t[:, 1:]), (q, k, v))
# let CLS token attend to key / values of all patches across time and space
cls_out = attn(cls_q, k, v)
# rearrange across time or space
q_, k_, v_ = map(lambda t: rearrange(t, f'{einops_from} -> {einops_to}', **einops_dims), (q_, k_, v_))
# expand cls token keys and values across time or space and concat
r = q_.shape[0] // cls_k.shape[0]
cls_k, cls_v = map(lambda t: repeat(t, 'b () d -> (b r) () d', r=r), (cls_k, cls_v))
k_ = torch.cat((cls_k, k_), dim=1)
v_ = torch.cat((cls_v, v_), dim=1)
# attention
out = attn(q_, k_, v_)
# merge back time or space
out = rearrange(out, f'{einops_to} -> {einops_from}', **einops_dims)
# concat back the cls token
out = torch.cat((cls_out, out), dim=1)
# merge back the heads
out = rearrange(out, '(b h) n d -> b n (h d)', h=h)
# to out
x = self.proj(out)
x = self.proj_drop(x)
return x
class SpaceTimeBlock(nn.Module):
def __init__(self, dim, num_heads, mlp_ratio=4., qkv_bias=False, qk_scale=None, drop=0., attn_drop=0.,
drop_path=0., act_layer=nn.GELU, norm_layer=nn.LayerNorm, time_init='zeros',
attention_style='frozen-in-time'):
super().__init__()
self.norm1 = norm_layer(dim)
self.attn = VarAttention(
dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop)
self.timeattn = VarAttention(
dim, num_heads=num_heads, qkv_bias=qkv_bias, qk_scale=qk_scale, attn_drop=attn_drop, proj_drop=drop,
initialize=time_init)
# NOTE: drop path for stochastic depth, we shall see if this is better than dropout here
self.drop_path = DropPath(drop_path) if drop_path > 0. else nn.Identity()
self.norm2 = norm_layer(dim)
mlp_hidden_dim = int(dim * mlp_ratio)
self.mlp = Mlp(in_features=dim, hidden_features=mlp_hidden_dim, act_layer=act_layer, drop=drop)
self.norm3 = norm_layer(dim)
self.attention_style = attention_style
def forward(self, x, einops_from_space, einops_to_space, einops_from_time, einops_to_time,
time_n, space_f):
time_output = self.timeattn(self.norm3(x), einops_from_time, einops_to_time, n=time_n)
time_residual = x + time_output
space_output = self.attn(self.norm1(time_residual), einops_from_space,
einops_to_space, f=space_f)
if self.attention_style == 'frozen-in-time':
space_residual = x + self.drop_path(space_output)
else:
raise NotImplementedError
x = space_residual + self.drop_path(self.mlp(self.norm2(space_residual)))
return x
class SpaceTimeTransformer(nn.Module):
""" Vision Transformer
A PyTorch impl of : `Space-Time Transformer` from Frozen-in-time - by Max Bain.
https://arxiv.org/abs/2104.00650
Based off:
- ViT implementation from the timm library
[https://github.com/rwightman/pytorch-image-models/blob/master/timm/models/vision_transformer.py]
lucidrains timesformer implementation [https://github.com/lucidrains/TimeSformer-pytorch].
Notable differences:
- allows for variable length input frames (<= num_frames)
- allows for variable length input resolution (<= (img_size, img_size)) [UNTESTED]
- different attention block mechanism
"""
def __init__(self, img_size=224, patch_size=16, in_chans=3, num_classes=1000, embed_dim=768, depth=12,
num_heads=12, mlp_ratio=4., qkv_bias=True, qk_scale=None, representation_size=None,
drop_rate=0., attn_drop_rate=0., drop_path_rate=0., hybrid_backbone=None, norm_layer=None,
num_frames=8, time_init='rand', attention_style='frozen-in-time'):
"""
Args:
img_size (int, tuple): input image size
patch_size (int, tuple): patch size
in_chans (int): number of input channels
num_classes (int): number of classes for classification head
embed_dim (int): embedding dimension
depth (int): depth of transformer
num_heads (int): number of attention heads
mlp_ratio (int): ratio of mlp hidden dim to embedding dim
qkv_bias (bool): enable bias for qkv if True
qk_scale (float): override default qk scale of head_dim ** -0.5 if set
representation_size (Optional[int]): enable and set representation layer (pre-logits) to this value if set
drop_rate (float): dropout rate
attn_drop_rate (float): attention dropout rate
drop_path_rate (float): stochastic depth rate
hybrid_backbone (nn.Module): CNN backbone to use in-place of PatchEmbed module
norm_layer: (nn.Module): normalization layer
num_frames: (int) maximum number of frames expected as input
time_init: (str) how to initialise the time attention layer, 'zeros' allows for the timesformer to start off
as ViT.
attention_style: (str) how to attend to space and time.
"""
super().__init__()
self.num_classes = num_classes
self.num_features = self.embed_dim = embed_dim # num_features for consistency with other models
self.num_frames = num_frames
self.embed_dim = embed_dim
norm_layer = norm_layer or partial(nn.LayerNorm, eps=1e-6)
# print("######USING ATTENTION STYLE: ", attention_style)
if hybrid_backbone is not None:
raise NotImplementedError('hybrid backbone not implemented')
else:
self.patch_embed = VideoPatchEmbed(
img_size=img_size, patch_size=patch_size, in_chans=in_chans, embed_dim=embed_dim, num_frames=num_frames)
num_patches = self.patch_embed.num_patches
self.patches_per_frame = num_patches // num_frames
self.cls_token = nn.Parameter(torch.zeros(1, 1, embed_dim))
self.pos_embed = nn.Parameter(
torch.zeros(1, self.patches_per_frame + 1,
embed_dim)) # remember to take pos_embed[1:] for tiling over time
self.temporal_embed = nn.Parameter(torch.zeros(1, num_frames, embed_dim))
self.pos_drop = nn.Dropout(p=drop_rate)
dpr = [x.item() for x in torch.linspace(0, drop_path_rate, depth)] # stochastic depth decay rule
self.blocks = nn.ModuleList([
SpaceTimeBlock(
dim=embed_dim, num_heads=num_heads, mlp_ratio=mlp_ratio, qkv_bias=qkv_bias, qk_scale=qk_scale,
drop=drop_rate, attn_drop=attn_drop_rate, drop_path=dpr[i], norm_layer=norm_layer, time_init=time_init,
attention_style=attention_style)
for i in range(depth)])
self.norm = norm_layer(embed_dim)
# Representation layer
if representation_size:
self.num_features = representation_size
self.pre_logits = nn.Sequential(OrderedDict([
('fc', nn.Linear(embed_dim, representation_size)),
('act', nn.Tanh())
]))
else:
self.pre_logits = nn.Identity()
# Classifier head
self.head = nn.Linear(self.num_features, num_classes) if num_classes > 0 else nn.Identity()
trunc_normal_(self.pos_embed, std=.02)
trunc_normal_(self.cls_token, std=.02)
# if num_frames > 1, then we perform ViT inflation and initialise time attention to zero so not necessary.
if num_frames == 1:
self.apply(self._init_weights)
# einops transformations
self.einops_from_space = 'b (f n) d'
self.einops_to_space = '(b f) n d'
self.einops_from_time = 'b (f n) d'
self.einops_to_time = '(b n) f d'
@staticmethod
def _init_weights(m):
if isinstance(m, nn.Linear):
trunc_normal_(m.weight, std=.02)
if isinstance(m, nn.Linear) and m.bias is not None:
nn.init.constant_(m.bias, 0)
elif isinstance(m, nn.LayerNorm):
nn.init.constant_(m.bias, 0)
nn.init.constant_(m.weight, 1.0)
@torch.jit.ignore
def no_weight_decay(self):
return {'pos_embed', 'cls_token'}
def get_classifier(self):
return self.head
def reset_classifier(self, num_classes):
self.num_classes = num_classes
self.head = nn.Linear(self.embed_dim, num_classes) if num_classes > 0 else nn.Identity()
def forward_features(self, x):
b, curr_frames, channels, _, _ = x.shape
x = self.patch_embed(x)
x = x.flatten(2).transpose(2, 1)
x = x.reshape(b, -1, self.patch_embed.embed_dim)
BF = x.shape[0]
cls_tokens = self.cls_token.expand(BF, -1, -1) # stole cls_tokens impl from Phil Wang, thanks
x = torch.cat((cls_tokens, x), dim=1)
# positional embed needs to be tiled for each frame (this does [1,2,3] --> [1,2,3,1,2,3]...)
cls_embed = self.pos_embed[:, 0, :].unsqueeze(1)
tile_pos_embed = self.pos_embed[:, 1:, :].repeat(1, self.num_frames, 1)
# temporal embed needs to be repeated within each frame (this does [1,2,3] --> [1,1,1,2,2,2,3,3,3]...)
tile_temporal_embed = self.temporal_embed.repeat_interleave(self.patches_per_frame, 1)
total_pos_embed = tile_pos_embed + tile_temporal_embed
total_pos_embed = torch.cat([cls_embed, total_pos_embed], dim=1)
curr_patches = x.shape[1]
x = x + total_pos_embed[:, :curr_patches]
x = self.pos_drop(x)
n = self.patches_per_frame
f = curr_frames
for blk in self.blocks:
x = blk(x, self.einops_from_space, self.einops_to_space, self.einops_from_time,
self.einops_to_time,
time_n=n, space_f=f)
x = self.norm(x)[:, 0]
x = self.pre_logits(x)
return x
def forward(self, x):
x = self.forward_features(x)
x = self.head(x)
return x
| 14,253 | 40.800587 | 120 | py |
fitclip | fitclip-main/aligner/encoder/clip_video_text_encoder.py | import os.path
import shutil
import tempfile
from typing import Iterable, Iterator, Tuple
import torch
from cached_path import cached_path
from clip import clip
from clip.model import CLIP
from overrides import overrides
from torch import nn
from torchvision import transforms as T
from aligner.data.frame_sampler import FrameSampler, RandomFromUniformIntervalsFrameSampler, UniformFrameSampler
from aligner.encoder.video_encoder import TYPE_TRANSFORM, float_standard_denormalize
from aligner.encoder.video_text_encoder import TYPE_TEXT_INPUT, TYPE_TOKENIZER, TYPE_VIDEO_INPUT, VideoTextEncoder
from aligner.transforms import ConvertBHWCtoBCHW, RandomResizedCropWithRandomInterpolation
# By default, `clip.load` uses part in half and part in single precision for GPU.
# But this may cause issues with the teacher-student model, and we can actually control it from the trainer.
def load_clip_in_float32(*args, **kwargs) -> Tuple[nn.Module, TYPE_TRANSFORM]:
model, transform = clip.load(*args, **kwargs)
model.float()
return model, transform
# Necessary to use from Hydra so to get the first element of the tuple from `clip.load`.
# It also does more stuff than `clip.load`.
def load_clip_model(name: str, *args, **kwargs) -> nn.Module:
temp_filepaths = []
try:
if "://" in name:
name = cached_path(name)
elif os.path.exists(name) and not os.path.isdir(name) and not os.path.isfile(name):
# It could be a pipe. It could be created by a process substitution.
# We copy it to a file because `clip.load` has a check that it's a file (and hence not a pipe).
with tempfile.NamedTemporaryFile(delete=False) as output_file, open(name, "rb") as input_file:
shutil.copyfileobj(input_file, output_file)
name = output_file.name
temp_filepaths.append(name)
# We don't use the logic scale from CLIP but ours, so it may not exist. Here we need to re-create the variable,
# so it doesn't fail when loading this `state_dict`.
if os.path.exists(name): # It doesn't apply if it's a model name.
state_dict = torch.load(name)
if "logit_scale" not in state_dict:
state_dict["logit_scale"] = torch.tensor(float("nan"))
with tempfile.NamedTemporaryFile(delete=False) as file:
# We create a new file to respect the original one.
torch.save(state_dict, file)
name = file.name
temp_filepaths.append(name)
if not args: # If `args` is not empty, then `device` was set for `clip.load`.
kwargs.setdefault("device", "cpu") # To avoid bloating GPU 0 with each process' copy of it.
return load_clip_in_float32(name, *args, **kwargs)[0]
finally:
for path in temp_filepaths:
os.remove(path)
def _tokenize(texts: Iterable[str]) -> TYPE_TEXT_INPUT:
return {"input_ids": clip.tokenize(texts, truncate=True)} # noqa
class ClipVideoTextEncoder(VideoTextEncoder):
def __init__(self, model: CLIP, num_frames: int = 4) -> None:
super().__init__()
self.model = model
self.normalize = T.Normalize(mean=(0.48145466, 0.4578275, 0.40821073), std=(0.26862954, 0.26130258, 0.27577711))
self.num_frames = num_frames
# Indirectly unregister the param as we don't use it and would otherwise give problems while training.
if hasattr(self.model, "logit_scale"):
delattr(self.model, "logit_scale")
@overrides
def encode_video(self, video: TYPE_VIDEO_INPUT) -> torch.Tensor:
batch_size = video.shape[0]
images = video.view(-1, *video.shape[2:])
encoded_video = self.model.encode_image(images)
encoded_video = encoded_video / encoded_video.norm(dim=-1, keepdim=True)
# Averaging the representations is the same as averaging the predictions:
# <t, (i1+i2)/2> = 1/2 <t, i1+i2> = (<t, i1> + <t, i2>) / 2
return encoded_video.view(batch_size, -1, *encoded_video.shape[1:]).mean(dim=1)
@overrides
def encode_text(self, text: TYPE_TEXT_INPUT) -> torch.Tensor:
encoded_texts = self.model.encode_text(text["input_ids"])
return encoded_texts / encoded_texts.norm(dim=-1, keepdim=True)
@overrides
def get_tokenizer(self) -> TYPE_TOKENIZER:
return _tokenize
@overrides
def decode_text(self, text: TYPE_TEXT_INPUT) -> Iterator[str]:
for text_instance in text:
yield clip._tokenizer.decode(text_instance["input_ids"])
@overrides
def get_train_frame_sampler(self) -> FrameSampler:
return RandomFromUniformIntervalsFrameSampler(self.num_frames)
@overrides
def get_eval_frame_sampler(self) -> FrameSampler:
return UniformFrameSampler(self.num_frames)
@overrides
def get_train_transform(self, dtype: torch.dtype) -> TYPE_TRANSFORM:
size = self.model.visual.input_resolution
return T.Compose([
ConvertBHWCtoBCHW(),
T.ConvertImageDtype(dtype),
RandomResizedCropWithRandomInterpolation(size, scale=(0.5, 1.0)),
T.RandomHorizontalFlip(),
self.normalize,
])
@overrides
def get_eval_transform(self, dtype: torch.dtype) -> TYPE_TRANSFORM:
size = self.model.visual.input_resolution
return T.Compose([
ConvertBHWCtoBCHW(),
T.ConvertImageDtype(dtype),
T.Resize(size, interpolation=T.InterpolationMode.BICUBIC),
T.CenterCrop(size),
self.normalize,
])
@property
@overrides
def should_pad_batch(self) -> bool:
return True
@overrides
def to_bchw(self, t: torch.Tensor) -> torch.Tensor:
return t
@overrides
def denormalize_video_tensor(self, video: TYPE_VIDEO_INPUT) -> torch.Tensor:
return float_standard_denormalize(video, mean=self.normalize.mean, std=self.normalize.std)
| 6,022 | 39.972789 | 120 | py |
fitclip | fitclip-main/aligner/encoder/slip_video_text_encoder.py | from typing import Iterable, Iterator, Union
import torch
from cached_path import cached_path
from overrides import overrides
from torchvision import transforms as T
from aligner.data.frame_sampler import FrameSampler, UniformFrameSampler
from aligner.encoder import slip
from aligner.encoder.slip import CLIP, SLIP, SimpleTokenizer
from aligner.encoder.video_encoder import TYPE_TRANSFORM, float_standard_denormalize
from aligner.encoder.video_text_encoder import TYPE_TEXT_INPUT, TYPE_TOKENIZER, TYPE_VIDEO_INPUT, VideoTextEncoder
from aligner.transforms import ConvertBHWCtoBCHW
from util.typing_utils import TYPE_PATH
def load_model(path: TYPE_PATH) -> Union[CLIP, SLIP]:
checkpoint = torch.load(cached_path(path), map_location="cpu")
args = checkpoint["args"]
model = getattr(slip, args.model)(rand_embed=False, ssl_mlp_dim=args.ssl_mlp_dim, ssl_emb_dim=args.ssl_emb_dim)
model.load_state_dict({k.replace("module.", ""): v for k, v in checkpoint["state_dict"].items()})
return model
class SlipVideoTextEncoder(VideoTextEncoder):
def __init__(self, model: Union[CLIP, SLIP], num_frames: int = 4) -> None:
super().__init__()
self.model = model
self.tokenizer = SimpleTokenizer()
self.num_frames = num_frames
# Indirectly unregister the param as we don't use it and would otherwise give problems while training.
if hasattr(self.model, "logit_scale"):
delattr(self.model, "logit_scale")
@overrides
def encode_video(self, video: TYPE_VIDEO_INPUT) -> torch.Tensor:
batch_size = video.shape[0] # noqa
images = video.view(-1, *video.shape[2:])
encoded_video = self.model.encode_image(images)
encoded_video = encoded_video / encoded_video.norm(dim=-1, keepdim=True)
# Averaging the representations is the same as averaging the predictions:
# <t, (i1+i2)/2> = 1/2 <t, i1+i2> = (<t, i1> + <t, i2>) / 2
return encoded_video.view(batch_size, -1, *encoded_video.shape[1:]).mean(dim=1)
@overrides
def encode_text(self, text: TYPE_TEXT_INPUT) -> torch.Tensor:
encoded_texts = self.model.encode_text(text["input_ids"])
return encoded_texts / encoded_texts.norm(dim=-1, keepdim=True)
def _tokenize(self, texts: Iterable[str]) -> TYPE_TEXT_INPUT:
return {"input_ids": self.tokenizer(texts)}
@overrides
def get_tokenizer(self) -> TYPE_TOKENIZER:
return self._tokenize
@overrides
def decode_text(self, text: TYPE_TEXT_INPUT) -> Iterator[str]:
for text_instance in text:
yield self.tokenizer.decode(text_instance["input_ids"])
@overrides
def get_train_frame_sampler(self) -> FrameSampler:
raise NotImplementedError
@overrides
def get_eval_frame_sampler(self) -> FrameSampler:
return UniformFrameSampler(self.num_frames)
@overrides
def get_train_transform(self, dtype: torch.dtype) -> TYPE_TRANSFORM:
raise NotImplementedError
@overrides
def get_eval_transform(self, dtype: torch.dtype) -> TYPE_TRANSFORM:
size = 224
return T.Compose([
ConvertBHWCtoBCHW(),
T.ConvertImageDtype(dtype),
T.Resize(size),
T.CenterCrop(size),
T.Normalize(mean=(0.485, 0.456, 0.406), std=(0.229, 0.224, 0.225)),
])
@property
@overrides
def should_pad_batch(self) -> bool:
return True
@overrides
def to_bchw(self, t: torch.Tensor) -> torch.Tensor:
return t
@overrides
def denormalize_video_tensor(self, video: TYPE_VIDEO_INPUT) -> torch.Tensor:
return float_standard_denormalize(video, mean=self.normalize.mean, std=self.normalize.std)
| 3,736 | 36.37 | 115 | py |
fitclip | fitclip-main/aligner/data/youcook2.py | import os
from glob import iglob
from typing import Optional, Tuple
import pandas as pd
from cached_path import cached_path
from overrides import overrides
from torch.utils.data import DataLoader
from aligner.data.video_data_module import VideoTextDataModule
from aligner.data.video_text_dataset import VideoTextDataset
from util.typing_utils import TYPE_PATH
VAL_VIDEO_INFO_FILE_PATH = "https://raw.githubusercontent.com/antoine77340/MIL-NCE_HowTo100M/master/csv/" \
"validation_youcook.csv"
# Videos can also be obtained from https://www.rocq.inria.fr/cluster-willow/amiech/Youcook2_val.zip!validation
VAL_VIDEOS_FOLDER = "/datasets/yc2_mil_nce_val/"
class YouCook2(VideoTextDataset):
def __init__(self, video_info_file_path: TYPE_PATH, videos_folder: TYPE_PATH, **kwargs) -> None:
self.video_info = pd.read_csv(cached_path(video_info_file_path), dtype={"task": str})
video_folder = cached_path(videos_folder)
video_paths = (next(iglob(os.path.join(video_folder, row.task, f"{row.video_id}.*")))
for _, row in self.video_info.iterrows())
super().__init__(video_paths=video_paths, **kwargs)
@overrides
def _get_target(self, video_idx: int) -> str:
return self.video_info.loc[video_idx, "text"]
@overrides
def _get_times(self, video_idx: int) -> Tuple[Optional[float], Optional[float]]:
row = self.video_info.loc[video_idx]
return row.start, row.end
class YouCook2DataModule(VideoTextDataModule): # noqa
def __init__(self, val_video_info_file_path: TYPE_PATH = VAL_VIDEO_INFO_FILE_PATH,
val_videos_folder: TYPE_PATH = VAL_VIDEOS_FOLDER, **kwargs) -> None:
super().__init__(**kwargs)
self.val_video_info_file_path = val_video_info_file_path
self.val_videos_folder = val_videos_folder
@overrides
def val_dataloader(self) -> DataLoader:
dataset = YouCook2(video_info_file_path=self.val_video_info_file_path, videos_folder=self.val_videos_folder,
**self._create_dataset_encoder_kwargs(train=False))
return self._create_dataloader(dataset, train=False)
| 2,183 | 41 | 116 | py |
fitclip | fitclip-main/aligner/data/moments_in_time.py | import functools
import os
from typing import Mapping, Tuple
import pandas as pd
from cached_path import cached_path
from overrides import overrides
from torch.utils.data import DataLoader
from aligner.data.video_data_module import VideoClassificationDataModule
from aligner.data.video_dataset import VideoDataset
from util.typing_utils import TYPE_PATH
from util.video_utils import get_sorted_videos_in_folder
CATEGORIES_FILE_PATH = "/datasets/moments-in-time/moments_categories.txt"
VAL_VIDEO_INFO_FILE_PATH = "/datasets/moments-in-time/validationSet.csv"
VAL_VIDEOS_FOLDER = "/datasets/moments-in-time/validation"
class MomentsInTime(VideoDataset):
def __init__(self, categories: Mapping[str, int], video_info_file_path: TYPE_PATH, videos_folder: TYPE_PATH,
**kwargs) -> None:
super().__init__(video_paths=get_sorted_videos_in_folder(cached_path(videos_folder)), **kwargs)
self.categories = categories
self.video_info = pd.read_csv(cached_path(video_info_file_path), names=["path", "category", "agreement",
"disagreement"], index_col="path")
@functools.lru_cache
@overrides
def _get_video_id(self, video_idx: int) -> str:
path = self.video_paths[video_idx]
folder_path, filename = os.path.split(path)
folder_name = os.path.basename(folder_path)
return os.path.join(folder_name, filename)
@overrides
def _get_target(self, video_idx: int) -> Tuple[str, int]:
video_id = self._get_video_id(video_idx)
category = self.video_info.loc[video_id, "category"]
return category, self.categories[category]
class MomentsInTimeDataModule(VideoClassificationDataModule): # noqa
categories = {} # Necessary because it's an abstract property. See https://stackoverflow.com/a/42529760/1165181
def __init__(self, categories_file_path: TYPE_PATH = CATEGORIES_FILE_PATH,
val_video_info_file_path: TYPE_PATH = VAL_VIDEO_INFO_FILE_PATH,
val_videos_folder: TYPE_PATH = VAL_VIDEOS_FOLDER, **kwargs) -> None:
super().__init__(**kwargs)
self.val_video_info_file_path = val_video_info_file_path
self.val_videos_folder = val_videos_folder
with open(cached_path(categories_file_path)) as file:
self.categories = {}
for line in file:
category, id_ = line.rstrip().split(",")
self.categories[category] = int(id_)
@overrides
def val_dataloader(self) -> DataLoader:
dataset = MomentsInTime(categories=self.categories, video_info_file_path=self.val_video_info_file_path,
videos_folder=self.val_videos_folder,
**self._create_dataset_encoder_kwargs(train=False))
return self._create_dataloader(dataset, train=False)
| 2,916 | 43.19697 | 116 | py |
fitclip | fitclip-main/aligner/data/frame_sampler.py | import itertools
from abc import ABC, abstractmethod
from typing import Optional, Sequence
import torch
from overrides import overrides
from util.iter_utils import pairwise
from util.video_utils import resample
class FrameSampler(ABC):
"""Returns the frame indices to seek for the given clip start and end frame indices."""
@abstractmethod
def __call__(self, start_frame: int, end_frame: int, fps: float) -> Sequence[int]:
raise NotImplementedError
class RandomFromUniformIntervalsFrameSampler(FrameSampler):
def __init__(self, max_frames: int) -> None:
super().__init__()
self.max_frames = max_frames
@overrides
def __call__(self, start_frame: int, end_frame: int, fps: float) -> Sequence[int]:
num_frames = min(self.max_frames, end_frame - start_frame + 1)
ticks = torch.linspace(start=start_frame, end=end_frame, steps=num_frames + 1, dtype=torch.int)
return [torch.randint(a, b + 1, size=()) for a, b in pairwise(ticks)]
class UniformFrameSampler(FrameSampler):
def __init__(self, max_frames: int) -> None:
super().__init__()
self.max_frames = max_frames
@overrides
def __call__(self, start_frame: int, end_frame: int, fps: float) -> Sequence[int]:
num_frames = min(self.max_frames, end_frame - start_frame + 1)
ticks = torch.linspace(start=start_frame, end=end_frame, steps=num_frames + 1, dtype=torch.int)
return [torch.round((a + b) / 2).to(torch.int) for a, b in pairwise(ticks)]
class FixedFrameFromUniformIntervalsFrameSampler(FrameSampler):
def __init__(self, max_frames: int, frame_index_from_interval_start: int) -> None:
super().__init__()
self.max_frames = max_frames
self.frame_index_from_interval_start = frame_index_from_interval_start
@overrides
def __call__(self, start_frame: int, end_frame: int, fps: float) -> Sequence[int]:
num_frames = min(self.max_frames, end_frame - start_frame + 1)
ticks = torch.linspace(start=start_frame, end=end_frame + 1, steps=num_frames + 1, dtype=torch.int)
return ticks[:-1] + self.frame_index_from_interval_start
class ConsecutiveFrameSampler(FrameSampler):
def __init__(self, max_frames: int, fps: Optional[int] = None) -> None:
super().__init__()
self.max_frames = max_frames
self.fps = fps
@overrides
def __call__(self, start_frame: int, end_frame: int, fps: float) -> Sequence[int]:
if self.fps:
indices = resample(num_frames=self.max_frames, original_fps=fps, new_fps=self.fps)
else:
indices = range(self.max_frames)
smallest_possible_end = min(end_frame, start_frame + indices[-1])
if isinstance(smallest_possible_end, torch.Tensor):
smallest_possible_end = smallest_possible_end.item() # To avoid a warning in the floor division.
start = start_frame + (end_frame - smallest_possible_end) // 2
return list(itertools.takewhile(lambda i: i <= end_frame, (start + i for i in indices)))
| 3,069 | 38.87013 | 109 | py |
fitclip | fitclip-main/aligner/data/video_reader.py | import logging
from abc import ABC, abstractmethod
from typing import Sequence, Union
import PIL
import decord
import numpy as np
import torch
import torchvision.datasets
import torchvision.transforms.functional
from overrides import overrides
from util.typing_utils import TYPE_PATH
LOGGER = logging.getLogger(__name__)
class VideoReader(ABC):
def __init__(self, path: TYPE_PATH) -> None: # noqa
pass
def __call__(self, indices: Sequence[int]) -> torch.Tensor:
raise NotImplementedError
@abstractmethod
def __len__(self) -> int:
raise NotImplementedError
@abstractmethod
def time_to_indices(self, time: Union[float, Sequence[float]]) -> np.ndarray:
raise NotImplementedError
@abstractmethod
def get_avg_fps(self) -> float:
raise NotImplementedError
@staticmethod
def from_path(path: TYPE_PATH) -> "VideoReader":
return (AccImageVideoReader if torchvision.datasets.folder.is_image_file(path) else DecordVideoReader)(path)
decord.bridge.set_bridge("torch")
class DecordVideoReader(VideoReader):
@overrides
def __init__(self, path: TYPE_PATH) -> None:
super().__init__(path)
# Using `width` and `height` from VideoReader is actually faster because it resizes while decoding, however
# it doesn't preserve the aspect ratio (even if setting only one of the two).
# Using the GPU for decoding may actually be faster, but it isn't trivial how to optimize the whole data loading
# process so to accomplish it.
try:
self.video_reader = decord.VideoReader(path, num_threads=1)
except decord.DECORDError:
LOGGER.error(f"An error occurred when trying to load the video with path {path}.")
self.video_reader = None
@overrides
def __call__(self, indices: Sequence[int]) -> torch.Tensor:
if self.video_reader:
try:
return self.video_reader.get_batch(indices) # noqa
except decord.DECORDError:
# FIXME: change the handle for the path? Or how to get the path
LOGGER.error(f"An error occurred when trying to read the video with path {self.video_reader._handle}"
f" and indices {indices}.")
return torch.zeros(len(indices), 256, 256, 3)
@overrides
def __len__(self) -> int:
return len(self.video_reader) if self.video_reader else 1
@overrides
def time_to_indices(self, time: Union[float, Sequence[float]]) -> np.ndarray:
times = self.video_reader.get_frame_timestamp(range(len(self))).mean(-1) if self.video_reader else np.zeros(1)
indices = np.searchsorted(times, time)
# Use `np.bitwise_or` so it works both with scalars and numpy arrays.
return np.where(np.bitwise_or(indices == 0, times[indices] - time <= time - times[indices - 1]), indices,
indices - 1)
@overrides
def get_avg_fps(self) -> float:
return self.video_reader.get_avg_fps() if self.video_reader else 1
torchvision.set_image_backend("accimage")
class AccImageVideoReader(VideoReader):
@overrides
def __init__(self, path: TYPE_PATH) -> None:
super().__init__(path)
self.path = path
@overrides
def __call__(self, indices: Sequence[int]) -> torch.Tensor:
try:
image = torchvision.datasets.folder.accimage_loader(self.path)
image_tensor = torchvision.transforms.functional.to_tensor(image)
return image_tensor.permute(1, 2, 0).unsqueeze(0)
except PIL.UnidentifiedImageError: # Note `accimage_loader` falls back to PIL.
LOGGER.error(f"An error occurred when trying to read the image with path {self.path}.")
return torch.zeros(len(indices), 256, 256, 3)
@overrides
def __len__(self) -> int:
return 1
@overrides
def time_to_indices(self, time: Union[float, Sequence[float]]) -> np.ndarray:
return np.zeros_like(time, dtype=int)
@overrides
def get_avg_fps(self) -> float:
return 1
| 4,118 | 33.90678 | 120 | py |
fitclip | fitclip-main/aligner/data/data_module_group.py | import bisect
from abc import ABC
from typing import Any, Callable, Iterable, Mapping, Optional, Sequence, Union
import pytorch_lightning as pl
from overrides import overrides
from pytorch_lightning import Trainer
from pytorch_lightning.trainer.states import RunningStage
from pytorch_lightning.utilities.apply_func import apply_to_collection
from pytorch_lightning.utilities.types import EVAL_DATALOADERS, TRAIN_DATALOADERS
from torch.utils.data import BatchSampler, ConcatDataset, DataLoader, Dataset, RandomSampler, SequentialSampler
from torchvision.datasets.samplers import DistributedSampler as DistributedSampler2
from aligner.data.multi_source_sampler import RoundRobinMultiSourceSampler
TYPE_DM_ITERABLE_OR_MAP = Union[Iterable[pl.LightningDataModule], Mapping[str, pl.LightningDataModule]]
def _data_modules_iterable(data_modules: TYPE_DM_ITERABLE_OR_MAP) -> Iterable[pl.LightningDataModule]:
return data_modules.values() if isinstance(data_modules, Mapping) else data_modules
def _data_loader_sequence(data_modules: TYPE_DM_ITERABLE_OR_MAP,
fn: Callable[[pl.LightningDataModule], EVAL_DATALOADERS]) -> Sequence[DataLoader]:
dls = (fn(dm) for dm in _data_modules_iterable(data_modules))
return [dl for dls_dm in dls for dl in ([dls_dm] if isinstance(dls_dm, DataLoader) else dls_dm)]
class _DataModuleGroup(pl.LightningDataModule, ABC):
def __init__(self, data_modules: TYPE_DM_ITERABLE_OR_MAP) -> None:
# Before calling super because it sets `trainer`, which recursively uses these.
self.data_modules = data_modules
self._trainer = None
super().__init__()
# Use it as a property, so we can set it to the data modules when set to self.
@property
def trainer(self) -> Trainer:
return self._trainer
@trainer.setter
def trainer(self, value: Trainer) -> None:
self._trainer = value
# `self.trainer` is set during `super().__init__`, which in turn it's called from `super().__new__`,
# which we can't control and happens before `self.data_modules` even exists.
# So we need to handle the case where the attribute doesn't exist.
for dm in _data_modules_iterable(getattr(self, "data_modules", [])):
dm.trainer = value
@overrides
def prepare_data(self) -> None:
for dm in _data_modules_iterable(self.data_modules):
dm.prepare_data()
@overrides
def setup(self, stage: Optional[str] = None) -> None:
for dm in _data_modules_iterable(self.data_modules):
dm.setup(stage)
class EvalDataModuleGroup(_DataModuleGroup): # noqa
@overrides
def val_dataloader(self) -> EVAL_DATALOADERS:
return _data_loader_sequence(self.data_modules, lambda dm: dm.val_dataloader())
@overrides
def test_dataloader(self) -> EVAL_DATALOADERS:
return _data_loader_sequence(self.data_modules, lambda dm: dm.test_dataloader())
@overrides
def predict_dataloader(self) -> EVAL_DATALOADERS:
return _data_loader_sequence(self.data_modules, lambda dm: dm.predict_dataloader())
class DataModuleStructuredGroup(EvalDataModuleGroup):
@overrides
def train_dataloader(self) -> TRAIN_DATALOADERS:
return apply_to_collection(self.data_modules, pl.LightningDataModule, lambda dm: dm.train_dataloader())
class ConcatDatasetWithDatasetKey(ConcatDataset):
"""A `ConcatDataset` that returns the corresponding dataset key for each item.
It supposes the underlying datasets all return mapping items.
"""
def __init__(self, datasets: Union[Iterable[Dataset], Mapping[str, Dataset]]) -> None:
super().__init__(datasets.values() if isinstance(datasets, Mapping) else datasets)
self.keys = list(datasets.keys()) if isinstance(datasets, Mapping) else range(len(self.datasets))
@overrides(check_signature=False)
def __getitem__(self, i: int) -> Mapping[Any, Any]:
item = super().__getitem__(i)
dataset_idx = bisect.bisect_right(self.cumulative_sizes, i)
return {**item, "dataset": self.keys[dataset_idx]}
def _add_distributed_sampler(data_loaders: EVAL_DATALOADERS, mode: RunningStage) -> EVAL_DATALOADERS:
assert all(apply_to_collection(data_loaders, DataLoader, lambda dl: isinstance(dl.sampler, SequentialSampler)))
return apply_to_collection(
data_loaders, DataLoader,
lambda dl: Trainer._update_dataloader(dl, DistributedSampler2(dl.dataset), mode=mode))
class MixedBatchDataModule(EvalDataModuleGroup):
"""A data module that combines many data modules during training, with the same dataset composition for each batch,
but separately for evaluation."""
def __init__(self, *args, train_sequence_sizes: Union[int, Iterable[int], Mapping[str, int]] = 1, **kwargs) -> None:
super().__init__(*args, **kwargs)
if isinstance(train_sequence_sizes, Mapping):
assert isinstance(self.data_modules, Mapping)
self.train_sequence_sizes = [train_sequence_sizes[k] for k in self.data_modules]
else:
self.train_sequence_sizes = train_sequence_sizes
if isinstance(self.train_sequence_sizes, int):
self.train_batch_size = len(self.data_modules) * self.train_sequence_sizes
else:
self.train_batch_size = sum(self.train_sequence_sizes)
@overrides
def train_dataloader(self) -> TRAIN_DATALOADERS:
data_loaders = apply_to_collection(self.data_modules, pl.LightningDataModule, lambda dm: dm.train_dataloader())
datasets = apply_to_collection(data_loaders, DataLoader, lambda dl: dl.dataset)
dataset = ConcatDatasetWithDatasetKey(datasets)
sub_samplers = [RandomSampler(dataset) for dataset in dataset.datasets] # noqa
sampler = RoundRobinMultiSourceSampler(sub_samplers, sequence_sizes=self.train_sequence_sizes,
mode="max_size_cycle")
data_loader_iterable = data_loaders.values() if isinstance(data_loaders, Mapping) else data_loaders
# We suppose each data module has the same args for the train data loader creation for the values obtained
# here from the first data loader.
first_data_loader = next(iter(data_loader_iterable))
# We have to create the batch sampler manually for the distributed setting.
# This is because we need to control how each batch is formed. If we don't do this, the distributed sampler
# comes before the batch sampling, and the mix composition of the batches won't be the intended one.
#
# For simplicity, we apply it regardless of distributed/non-distributed setup.
batch_sampler = BatchSampler(sampler, batch_size=self.train_batch_size, drop_last=True)
if self.trainer._accelerator_connector.is_distributed:
# We need to manually set the distributed sampler instead of doing it automatically with Pytorch Lightning
# because we're using a custom sampler.
#
# This version of DistributedSampler accounts for having a sampler as input.
#
# BTW, there's a similar one (`DistributedSamplerWrapper`) in
# https://github.com/catalyst-team/catalyst/blob/master/catalyst/data/sampler.py
batch_sampler = DistributedSampler2(batch_sampler)
# We need to set the sampler as a `batch_sampler` so it activates the auto-collation in the data loader.
data_loader = DataLoader(dataset, batch_sampler=batch_sampler, num_workers=first_data_loader.num_workers,
collate_fn=first_data_loader.collate_fn, pin_memory=first_data_loader.pin_memory,
timeout=first_data_loader.timeout, worker_init_fn=first_data_loader.worker_init_fn,
multiprocessing_context=first_data_loader.multiprocessing_context,
prefetch_factor=first_data_loader.prefetch_factor,
persistent_workers=first_data_loader.persistent_workers)
if self.trainer._accelerator_connector.is_distributed:
# PL only sets the epoch to the sampler, not to the batch sampler. This is because the distributed
# sampler is typically the former not the latter.
# Note that setting the epoch is necessary for shuffling, so every epoch has different batches.
data_loader.sampler.set_epoch = lambda epoch: batch_sampler.set_epoch(epoch)
return data_loader
def _add_distributed_sampler_maybe(self, data_loaders: EVAL_DATALOADERS, mode: RunningStage) -> EVAL_DATALOADERS:
if self.trainer._accelerator_connector.is_distributed:
return _add_distributed_sampler(data_loaders, mode)
else:
return data_loaders
@overrides
def val_dataloader(self) -> EVAL_DATALOADERS:
return self._add_distributed_sampler_maybe(super().val_dataloader(), RunningStage.VALIDATING)
@overrides
def test_dataloader(self) -> EVAL_DATALOADERS:
return self._add_distributed_sampler_maybe(super().test_dataloader(), RunningStage.TESTING)
@overrides
def predict_dataloader(self) -> EVAL_DATALOADERS:
return self._add_distributed_sampler_maybe(super().predict_dataloader(), RunningStage.PREDICTING)
class TrainAndEvalDataModules(_DataModuleGroup):
def __init__(self, train_data_module: pl.LightningDataModule, eval_data_module: pl.LightningDataModule) -> None:
super().__init__([train_data_module, eval_data_module])
@overrides
def train_dataloader(self) -> TRAIN_DATALOADERS:
return self.data_modules[0].train_dataloader() # noqa
@overrides
def val_dataloader(self) -> EVAL_DATALOADERS:
return self.data_modules[1].val_dataloader() # noqa
@overrides
def test_dataloader(self) -> EVAL_DATALOADERS:
return self.data_modules[1].test_dataloader() # noqa
@overrides
def predict_dataloader(self) -> EVAL_DATALOADERS:
return self.data_modules[1].predict_dataloader() # noqa
| 10,134 | 47.492823 | 120 | py |
fitclip | fitclip-main/aligner/data/multi_source_sampler.py | import itertools
import math
import sys
from typing import Generic, Iterable, Iterator, Literal, TypeVar, Union
from torch.utils.data import Sampler
T_co = TypeVar("T_co", covariant=True)
# We don't use `CycleIterator` from PyTorch Lightning because when used along with `itertools.islice`,
# it always creates a new iterator and wrongly starts from scratch because it's both an iterable and iterator (seems
# like the function calls `iter` internally).
class CycleSampler(Generic[T_co]):
def __init__(self, data_source: Iterable[T_co], length: int = sys.maxsize) -> None:
self.length = length
self.data_source = data_source
def __iter__(self) -> Iterator[T_co]:
if not self.length:
return
counter = 0
while True:
it = iter(self.data_source)
for elem in it:
yield elem
counter += 1
if counter >= self.length:
return
def __len__(self) -> int:
return self.length
class RoundRobinMultiSourceSampler(Sampler[int]):
"""
It supposes the dataset passed along to the `DataLoader` instance is a `ConcatDataset` instance.
Recommended to use with `drop_last=True`.
Some inspiration comes from the module `pytorch_lightning.trainer.supporters`.
"""
def __init__(self, sub_samplers: Iterable[Iterable[int]], sequence_sizes: Union[int, Iterable[int]] = 1,
mode: Literal["min_size", "max_size_cycle"] = "min_size") -> None:
sub_samplers = list(sub_samplers)
sequence_sizes = list(sequence_sizes) if isinstance(sequence_sizes, Iterable) \
else [sequence_sizes] * len(sub_samplers)
assert len(sub_samplers) == len(sequence_sizes)
assert all(len(sampler) for sampler in sub_samplers), ("All sub-samplers need to support `len` and be " # noqa
"non-zero.")
assert all(s > 0 for s in sequence_sizes)
super().__init__(sub_samplers)
self.sub_samplers = sub_samplers
self.sequence_sizes = sequence_sizes
self.mode = mode
for sampler in self.sub_samplers:
sampler._original_len = len(sampler) # noqa
if mode == "max_size_cycle":
max_cycle, max_i = max((math.floor(cycle), - i) for i, cycle in enumerate(self._cycles()))
max_i *= -1 # Trick to get the first sampler index among those of max cycle size.
# Use a large number instead of the default inf because `len` can fail otherwise.
# See https://stackoverflow.com/a/2481631/1165181
self.sub_samplers = [sampler if i == max_i else CycleSampler(sampler, length=sys.maxsize)
for i, sampler in enumerate(self.sub_samplers)]
for i, sampler in enumerate(self.sub_samplers):
if i != max_i:
sampler._original_len = len(sampler.data_source) # noqa
def _cycles(self) -> Iterator[float]:
for sampler, seq_size in zip(self.sub_samplers, self.sequence_sizes):
yield len(sampler) / seq_size
def __iter__(self) -> Iterator[int]:
iterators = [iter(sampler) for sampler in self.sub_samplers]
while True:
cum_size_in_concat_dataset = 0
for it, size, sampler in zip(iterators, self.sequence_sizes, self.sub_samplers):
i = -1
for i, n in enumerate(itertools.islice(it, size)):
yield cum_size_in_concat_dataset + n
if i < size - 1:
return
cum_size_in_concat_dataset += sampler._original_len # noqa
def __len__(self) -> int:
# Note in "max_size_cycle" mode the longest sampler will actually be the smallest one because the rest are
# repeated infinitely.
min_cycle, min_i = min((math.floor(cycle), i) for i, cycle in enumerate(self._cycles()))
return (sum(seq_size * (min_cycle + int(i < min_i)) for i, seq_size in enumerate(self.sequence_sizes))
+ len(self.sub_samplers[min_i]) % self.sequence_sizes[min_i])
| 4,191 | 38.92381 | 119 | py |
fitclip | fitclip-main/aligner/data/video_data_module.py | import multiprocessing
from abc import ABC, abstractmethod
from typing import Any, Iterable, Mapping, MutableMapping, Optional, Union
import pytorch_lightning as pl
import torch.cuda
from overrides import overrides
from pytorch_lightning.utilities.apply_func import apply_to_collection
from torch.utils.data import DataLoader
from aligner.data.frame_sampler import FrameSampler
from aligner.data.video_dataset import VideoDataset
from aligner.encoder.video_encoder import TYPE_TRANSFORM, VideoEncoder
from aligner.encoder.video_text_encoder import VideoTextEncoder
ENCODER_OR_ENCODER_MAP = Union[VideoEncoder, Mapping[str, VideoEncoder]]
def precision_to_dtype(precision: Union[str, int]) -> torch.dtype:
if precision == 32:
return torch.float
elif precision == 64:
return torch.float64
elif precision in {16, "mixed"}:
return torch.float16
else:
raise ValueError(f"Unsupported precision value: {precision}")
class VideoDataModule(pl.LightningDataModule, ABC):
def __init__(self, encoder: ENCODER_OR_ENCODER_MAP, batch_size: Optional[int] = 1,
eval_batch_size: Optional[int] = 32,
num_workers: int = multiprocessing.cpu_count() // max(torch.cuda.device_count(), 1)) -> None:
super().__init__()
self.encoder = encoder
self.batch_size = batch_size
self.eval_batch_size = eval_batch_size
self.num_workers = num_workers
def _create_transform(self, train: bool) -> Union[TYPE_TRANSFORM, Mapping[str, TYPE_TRANSFORM]]:
float_precision = self.trainer.precision_plugin.precision
dtype = precision_to_dtype(float_precision)
return apply_to_collection(self.encoder, VideoEncoder,
lambda e: (e.get_train_transform if train else e.get_eval_transform)(dtype))
def _create_frame_sampler(self, train: bool) -> Union[FrameSampler, Mapping[str, FrameSampler]]:
return apply_to_collection(self.encoder, VideoEncoder,
lambda e: e.get_train_frame_sampler() if train else e.get_eval_frame_sampler())
def _create_dataset_encoder_kwargs(self, train: bool) -> MutableMapping[str, Any]:
# FIXME: Disable the cache because it seems like a new dataset is created by PL every time.
return {"frame_sampler": self._create_frame_sampler(train=train),
"transform": self._create_transform(train=train),
"pad_batch": apply_to_collection(self.encoder, VideoEncoder, lambda e: e.should_pad_batch),
"cache": False}
def _create_dataloader(self, dataset: VideoDataset, train: bool) -> DataLoader:
# Drop last in train so the NCE loss isn't smaller in the charts for the last batch.
# Also, don't waste one step with fewer memory, where we could have the next one with more memory.
batch_size = self.batch_size if train else self.eval_batch_size
return DataLoader(dataset, batch_size=batch_size, num_workers=self.num_workers, pin_memory=True,
persistent_workers=self.num_workers > 0, collate_fn=getattr(dataset, "collate", None),
shuffle=train, drop_last=train)
@overrides
def predict_dataloader(self) -> DataLoader:
return self.val_dataloader()
class VideoTextDataModule(VideoDataModule, ABC):
def __init__(self, encoder: Union[VideoTextEncoder, Mapping[str, VideoTextEncoder]], **kwargs) -> None:
super().__init__(encoder=encoder, **kwargs)
@overrides
def _create_dataset_encoder_kwargs(self, train: bool) -> MutableMapping[str, Any]:
kwargs = super()._create_dataset_encoder_kwargs(train=train)
kwargs["tokenizer"] = apply_to_collection(self.encoder, VideoEncoder, lambda e: e.get_tokenizer())
return kwargs
class VideoClassificationDataModule(VideoDataModule, ABC):
@property
@abstractmethod
def categories(self) -> Mapping[str, int]:
raise NotImplementedError
@property
def templates(self) -> Optional[Iterable[str]]:
return None
| 4,101 | 44.577778 | 114 | py |
fitclip | fitclip-main/aligner/data/video_text_dataset.py | from abc import ABC
from typing import Mapping, Union
from torch.utils.data.dataloader import default_collate
from aligner.data.tokenizer_collate import MappingTokenizerCollate
from aligner.data.video_dataset import VideoDataset
from aligner.encoder.video_text_encoder import TYPE_TOKENIZER
class VideoTextDataset(VideoDataset, ABC):
def __init__(self, tokenizer: Union[TYPE_TOKENIZER, Mapping[str, TYPE_TOKENIZER]], target_key_name: str = "text",
**kwargs) -> None:
super().__init__(target_key_name=target_key_name, **kwargs)
self.collate = MappingTokenizerCollate(tokenizer, target_key_name,
default_collate_fn=getattr(self, "collate", default_collate))
| 744 | 42.823529 | 117 | py |
fitclip | fitclip-main/aligner/data/hmdb.py | import functools
import glob
import os
from typing import Iterable, Literal, Mapping, Optional, Tuple
from cached_path import cached_path
from overrides import overrides
from torch.utils.data import DataLoader
from aligner.data.ucf import UCF_101_TEMPLATES
from aligner.data.video_data_module import VideoClassificationDataModule
from aligner.data.video_dataset import VideoDataset
from util.typing_utils import TYPE_PATH
TRAIN_TAG = 1
TEST_TAG = 2
class Hmdb(VideoDataset):
def __init__(self, categories: Mapping[str, int], splits_folder: TYPE_PATH, split: Literal[1, 2, 3],
tag: Literal[1, 2], videos_folder: TYPE_PATH, **kwargs) -> None:
self.categories = categories
videos_folder = cached_path(videos_folder)
video_paths = []
for path in glob.iglob(os.path.join(cached_path(splits_folder), f"*_test_split{split}.txt")):
category = os.path.basename(path).rsplit("_", maxsplit=2)[0]
with open(path) as file:
for line in file:
filename, file_tag = line.strip().split(maxsplit=1)
file_tag = int(file_tag)
if file_tag == tag:
video_paths.append(os.path.join(videos_folder, category, filename))
super().__init__(video_paths=video_paths, **kwargs)
@functools.lru_cache
@overrides
def _get_video_id(self, video_idx: int) -> str:
path = self.video_paths[video_idx]
folder_path, filename = os.path.split(path)
folder_name = os.path.basename(folder_path)
return os.path.join(folder_name, filename)
@functools.lru_cache
@overrides
def _get_target(self, video_idx: int) -> Tuple[str, int]:
video_id = self._get_video_id(video_idx)
folder_name = os.path.dirname(video_id)
category = folder_name.replace("_", " ")
return category, self.categories[category]
class HmdbDataModule(VideoClassificationDataModule): # noqa
categories = {} # Necessary because it's an abstract property. See https://stackoverflow.com/a/42529760/1165181
def __init__(self, categories_file_path: TYPE_PATH, splits_folder: TYPE_PATH, split: Literal[1, 2, 3],
videos_folder: TYPE_PATH, **kwargs) -> None:
super().__init__(**kwargs)
self.splits_folder = splits_folder
self.split = split
self.videos_folder = videos_folder
with open(cached_path(categories_file_path)) as file:
self.categories = {line.strip(): i for i, line in enumerate(file)}
@property
@overrides
def templates(self) -> Optional[Iterable[str]]:
return UCF_101_TEMPLATES
@overrides
def train_dataloader(self) -> DataLoader:
dataset = Hmdb(categories=self.categories, splits_folder=self.splits_folder, split=self.split,
tag=TRAIN_TAG, videos_folder=self.videos_folder, # noqa
**self._create_dataset_encoder_kwargs(train=True))
return self._create_dataloader(dataset, train=True)
@overrides
def val_dataloader(self) -> DataLoader:
dataset = Hmdb(categories=self.categories, splits_folder=self.splits_folder, split=self.split,
tag=TEST_TAG, videos_folder=self.videos_folder, # noqa
**self._create_dataset_encoder_kwargs(train=False))
return self._create_dataloader(dataset, train=False)
| 3,441 | 39.023256 | 116 | py |
fitclip | fitclip-main/aligner/data/webvid.py | import os
import pandas as pd
from cached_path import cached_path
from overrides import overrides
from torch.utils.data import DataLoader
from aligner.data.video_data_module import VideoTextDataModule
from aligner.data.video_dataset import VideoDataset
from aligner.data.video_text_dataset import VideoTextDataset
from util.typing_utils import TYPE_PATH
from util.video_utils import get_sorted_videos_in_folder
TRAIN_VIDEO_INFO_FILE_PATH = "/datasets/webvid/results_2M_train.csv"
# noinspection SpellCheckingInspection
TRAIN_VIDEOS_FOLDER = "/datasets/webvid/videos_low_resolution/train/webvid_lowres/"
VAL_VIDEO_INFO_FILE_PATH = "/datasets/webvid/results_2M_val.csv"
# noinspection SpellCheckingInspection
VAL_VIDEOS_FOLDER = "/datasets/webvid/videos_low_resolution/val/val_lowres/"
class WebVid(VideoTextDataset):
def __init__(self, video_info_file_path: TYPE_PATH, videos_folder: TYPE_PATH,
filter_videos_from_info_file: bool = False, **kwargs) -> None:
# noinspection SpellCheckingInspection
self.video_info = pd.read_csv(cached_path(video_info_file_path), index_col="videoid", dtype={"videoid": str})
if filter_videos_from_info_file:
video_paths = (cached_path(os.path.join(videos_folder, f"{video_id}.mp4"))
for video_id, _ in self.video_info.iterrows())
else:
video_paths = get_sorted_videos_in_folder(cached_path(videos_folder))
super().__init__(video_paths=video_paths, **kwargs)
@overrides
def _get_target(self, video_idx: int) -> str:
video_id = self._get_video_id(video_idx)
return self.video_info.loc[video_id, "name"]
class WebVidDataModule(VideoTextDataModule): # noqa
def __init__(self, train_video_info_file_path: TYPE_PATH = TRAIN_VIDEO_INFO_FILE_PATH,
train_videos_folder: TYPE_PATH = TRAIN_VIDEOS_FOLDER, train_filter_videos_from_info_file: bool = False,
val_video_info_file_path: TYPE_PATH = VAL_VIDEO_INFO_FILE_PATH,
val_videos_folder: TYPE_PATH = VAL_VIDEOS_FOLDER, val_filter_videos_from_info_file: bool = False,
**kwargs) -> None:
super().__init__(**kwargs)
self.train_video_info_file_path = train_video_info_file_path
self.train_videos_folder = train_videos_folder
self.train_filter_videos_from_info_file = train_filter_videos_from_info_file
self.val_video_info_file_path = val_video_info_file_path
self.val_videos_folder = val_videos_folder
self.val_filter_videos_from_info_file = val_filter_videos_from_info_file
def _dataset(self, video_info_file_path: TYPE_PATH, videos_folder: TYPE_PATH,
filter_videos_from_info_file: bool, train: bool) -> VideoDataset:
return WebVid(video_info_file_path=video_info_file_path, videos_folder=videos_folder,
filter_videos_from_info_file=filter_videos_from_info_file,
**self._create_dataset_encoder_kwargs(train=train))
@overrides
def train_dataloader(self) -> DataLoader:
dataset = self._dataset(video_info_file_path=self.train_video_info_file_path,
videos_folder=self.train_videos_folder,
filter_videos_from_info_file=self.train_filter_videos_from_info_file, train=True)
return self._create_dataloader(dataset, train=True)
@overrides
def val_dataloader(self) -> DataLoader:
dataset = self._dataset(video_info_file_path=self.val_video_info_file_path,
videos_folder=self.val_videos_folder,
filter_videos_from_info_file=self.val_filter_videos_from_info_file, train=False)
return self._create_dataloader(dataset, train=False)
| 3,814 | 49.197368 | 120 | py |
fitclip | fitclip-main/aligner/data/video_dataset.py | import collections.abc
import functools
import logging
import os
from abc import ABC, abstractmethod
from typing import Any, Generic, Iterable, Mapping, Optional, Sequence, Tuple, TypeVar, Union
import torch
from overrides import overrides
from torch.nn.utils.rnn import pad_sequence
from torch.utils.data import Dataset
from torch.utils.data.dataloader import default_collate
from aligner.data.frame_sampler import FrameSampler
from aligner.data.video_reader import VideoReader
from aligner.encoder.video_encoder import TYPE_TRANSFORM
from util.typing_utils import TYPE_PATH
T = TypeVar("T")
LOGGER = logging.getLogger(__name__)
def get_filename_without_extension(path: TYPE_PATH) -> str:
return os.path.basename(path).split(".", maxsplit=1)[0]
# TODO: support taking multiple clips per video, where they are chosen according to some strategy.
class VideoDataset(Dataset, Generic[T], ABC):
def __init__(self, video_paths: Iterable[TYPE_PATH], frame_sampler: Union[FrameSampler, Mapping[str, FrameSampler]],
transform: Union[TYPE_TRANSFORM, Mapping[str, TYPE_TRANSFORM]] = lambda x: x,
video_key_name: str = "video", target_key_name: str = "target", pad_batch: bool = True,
cache: bool = False) -> None:
super().__init__()
self.video_paths = video_paths if hasattr(video_paths, "__getitem__") else list(video_paths)
self.target_key_name = target_key_name
self.pad_batch = pad_batch
self.cache = cache
if isinstance(frame_sampler, Mapping):
self.frame_sampler_map = {f"{video_key_name}_{k}": v for k, v in frame_sampler.items()}
else:
self.frame_sampler_map = {video_key_name: frame_sampler}
if isinstance(transform, Mapping):
self.transform_map = {f"{video_key_name}_{k}": v for k, v in transform.items()}
else:
self.transform_map = {video_key_name: transform}
if set(self.frame_sampler_map) != set(self.transform_map):
if video_key_name in self.frame_sampler_map:
self.frame_sampler_map = {k: self.frame_sampler_map[video_key_name] for k in self.transform_map}
elif video_key_name in self.transform_map:
self.transform_map = {k: self.transform_map[video_key_name] for k in self.frame_sampler_map}
else:
raise ValueError("The provided keys for the frame sampler and the transform don't match.")
@abstractmethod
def _get_target(self, video_idx: int) -> T:
"""Returns the target associated with `self.video_paths[video_idx]`."""
raise NotImplementedError
@functools.lru_cache
def _get_video_id(self, video_idx: int) -> str:
return get_filename_without_extension(self.video_paths[video_idx])
def _get_times(self, video_idx: int) -> Tuple[Optional[float], Optional[float]]:
"""Returns the video clip start and end times for the given video index, if any."""
return None, None
@functools.lru_cache(maxsize=None)
def _cached_get_item(self, video_idx: int) -> Mapping[str, Union[torch.Tensor, str, T]]:
path = self.video_paths[video_idx]
video_id = self._get_video_id(video_idx)
video_reader = VideoReader.from_path(path)
start_time, end_time = self._get_times(video_idx)
start_frame_idx = 0 if start_time is None else video_reader.time_to_indices(start_time).item()
end_frame_idx = len(video_reader) - 1 if end_time is None else video_reader.time_to_indices(end_time).item()
idxs_map = {k: frame_sampler(start_frame_idx, end_frame_idx, fps=video_reader.get_avg_fps())
for k, frame_sampler in self.frame_sampler_map.items()}
frames_map = {k: video_reader(idxs) for k, idxs in idxs_map.items()}
return {
self.target_key_name: self._get_target(video_idx),
"video_id": video_id,
**{k: transform(frames_map[k]) for k, transform in self.transform_map.items()},
}
@overrides
def __getitem__(self, video_idx: int) -> Mapping[str, Union[torch.Tensor, str, T]]:
# Note we have to explicitly pass `self` to the wrapped one.
fn = self._cached_get_item if self.cache else functools.partial(self._cached_get_item.__wrapped__, self) # noqa
return fn(video_idx)
def __len__(self) -> int:
return len(self.video_paths)
def _collate(self, batch: Sequence[Any]) -> Any:
if self.pad_batch:
elem = batch[0]
if isinstance(elem, torch.Tensor):
return pad_sequence(batch, batch_first=True) # noqa
elif isinstance(elem, collections.abc.Mapping):
return {k: self._collate([d[k] for d in batch]) if k in self.transform_map
else default_collate([d[k] for d in batch])
for k in elem}
return default_collate(batch)
def collate(self, batch: Sequence[Any]) -> Any:
# Use an auxiliary function instead of doing it directly here because it's recursive, and it may also be
# overridden. so in the recursion the overridden version may be called instead of this one.
return self._collate(batch)
| 5,261 | 43.59322 | 120 | py |
fitclip | fitclip-main/aligner/data/tokenizer_collate.py | import collections.abc
from abc import ABC, abstractmethod
from typing import Any, Callable, Iterable, Mapping, Sequence, Tuple, Union
from overrides import overrides
from pytorch_lightning.utilities.apply_func import apply_to_collection
from torch.utils.data.dataloader import default_collate
from aligner.encoder.video_text_encoder import TYPE_TOKENIZER
# Derived from `default_collate`.
def batch_tokenize_collate(batch: Sequence[Any], tokenizer: TYPE_TOKENIZER) -> Any:
elem = batch[0]
elem_type = type(elem)
if isinstance(elem, (str, bytes)):
return tokenizer(batch)
elif isinstance(elem, collections.abc.Mapping):
return {k: batch_tokenize_collate([d[k] for d in batch], tokenizer) for k in elem}
elif isinstance(elem, tuple) and hasattr(elem, '_fields'): # namedtuple
return elem_type(*(batch_tokenize_collate(samples, tokenizer) for samples in zip(*batch)))
elif isinstance(elem, collections.abc.Sequence):
# check to make sure that the elements in batch have consistent size
it = iter(batch)
elem_size = len(next(it))
if not all(len(elem) == elem_size for elem in it):
raise RuntimeError("Each element in sequence of batch should be of equal size.")
transposed = zip(*batch)
return [batch_tokenize_collate(samples, tokenizer) for samples in transposed]
else:
raise TypeError(f"Batch must contain strings, mappings or sequences; found {elem_type}.")
class TokenizerCollate(ABC):
"""`DataLoader` collate function that batch-tokenizes part of the batch.
The pros of batch-tokenizing during collation are:
1) We can pad at the same time, based on the longest sequence. If we tokenized in the dataset, we wouldn't know
what size to take, and we may take a long one, wasting computing and especially memory. If we batch-tokenize when
iterating through the data_module loader, we are in the main thread and wasting valuable time that could be used for
the GPU.
2) The `tokenizers` library is written in Rust and may have some optimizations for batch-tokenizing (apart from
multi-threading, which is disabled so each data_module loader worker uses one CPU core.)
"""
def __init__(self, tokenizer: Union[TYPE_TOKENIZER, Mapping[str, TYPE_TOKENIZER]], *,
batch_tokenize_collate_fn: Callable[[Sequence[Any], TYPE_TOKENIZER], Any] = batch_tokenize_collate,
default_collate_fn: Callable[[Sequence[Any]], Any] = default_collate) -> None:
super().__init__()
self.tokenizer = tokenizer
self.batch_tokenize_collate_fn = batch_tokenize_collate_fn
self.default_collate_fn = default_collate_fn
@abstractmethod
def _split_uncollated_batch(self, batch: Sequence[Any]) -> Tuple[Sequence[Any], Sequence[Any]]:
"""Splits the batch into a pair where the first element is going to be processed with the default collate
function and each of the elements in the second one are going to be batch-tokenized."""
raise NotImplementedError
@abstractmethod
def _join_collated_batch(self, collated_with_default: Any, collated_with_tokenizer: Any) -> Any:
raise NotImplementedError
def __call__(self, batch: Sequence[Any]) -> Any:
s1, s2 = self._split_uncollated_batch(batch)
batch_tokenized = apply_to_collection(self.tokenizer, Callable, lambda t: self.batch_tokenize_collate_fn(s2, t))
return self._join_collated_batch(self.default_collate_fn(s1), batch_tokenized)
class MappingTokenizerCollate(TokenizerCollate):
def __init__(self, tokenizer: TYPE_TOKENIZER, keys_to_tokenize: Union[str, Iterable[str]], **kwargs) -> None:
super().__init__(tokenizer, **kwargs)
self.keys_to_tokenize = frozenset({keys_to_tokenize} if isinstance(keys_to_tokenize, str) else keys_to_tokenize)
@overrides(check_signature=False)
def _split_uncollated_batch(self,
batch: Sequence[Mapping[str, Any]]) -> Tuple[Sequence[Any], Sequence[Any]]:
return [{k: v for k, v in d.items() if k not in self.keys_to_tokenize} for d in batch], \
[{k: v for k, v in d.items() if k in self.keys_to_tokenize} for d in batch]
@overrides(check_signature=False)
def _join_collated_batch(self, collated_with_default: Any, collated_with_tokenizer: Any) -> Any:
# If the tokenizer is actually composed of many tokenizers, we flatten out the structure.
if isinstance(self.tokenizer, Mapping):
collated_with_tokenizer = {f"{k_child}_{k_parent}": v_child
for k_parent, v_parent in collated_with_tokenizer.items()
for k_child, v_child in v_parent.items()}
return {**collated_with_default, **collated_with_tokenizer}
| 4,865 | 53.066667 | 120 | py |
fitclip | fitclip-main/aligner/data/kinetics.py | import os
from typing import Iterable, Mapping, Optional, Tuple
import pandas as pd
from cached_path import cached_path
from overrides import overrides
from torch.utils.data import DataLoader
from aligner.data.video_data_module import VideoClassificationDataModule
from aligner.data.video_dataset import VideoDataset
from util.typing_utils import TYPE_PATH
from util.video_utils import get_sorted_videos_in_folder
class Kinetics(VideoDataset):
def __init__(self, categories: Mapping[str, int], video_info_file_path: TYPE_PATH, videos_folder: TYPE_PATH,
filter_videos_from_info_file: bool = False, **kwargs) -> None:
self.categories = categories
self.video_info = pd.read_csv(cached_path(video_info_file_path))
self.video_info["video_id"] = \
self.video_info.agg(lambda row: f"{row.youtube_id}_{row.time_start:06}_{row.time_end:06}", axis=1)
self.video_info.set_index("video_id", inplace=True)
if filter_videos_from_info_file:
video_paths = (cached_path(os.path.join(videos_folder, f"{video_id}.mp4"))
for video_id, _ in self.video_info.iterrows())
else:
video_paths = get_sorted_videos_in_folder(cached_path(videos_folder))
super().__init__(video_paths=video_paths, **kwargs)
@overrides
def _get_target(self, video_idx: int) -> Tuple[str, int]:
video_id = self._get_video_id(video_idx)
category = self.video_info.loc[video_id, "label"]
return category, self.categories[category]
class KineticsDataModule(VideoClassificationDataModule): # noqa
categories = {} # Necessary because it's an abstract property. See https://stackoverflow.com/a/42529760/1165181
def __init__(self, categories_file_path: TYPE_PATH, train_video_info_file_path: TYPE_PATH,
train_videos_folder: TYPE_PATH, val_video_info_file_path: TYPE_PATH, val_videos_folder: TYPE_PATH,
test_video_info_file_path: TYPE_PATH, test_videos_folder: TYPE_PATH,
train_filter_videos_from_info_file: bool = False, val_filter_videos_from_info_file: bool = False,
test_filter_videos_from_info_file: bool = False, **kwargs) -> None:
super().__init__(**kwargs)
self.train_video_info_file_path = train_video_info_file_path
self.train_videos_folder = train_videos_folder
self.train_filter_videos_from_info_file = train_filter_videos_from_info_file
self.val_video_info_file_path = val_video_info_file_path
self.val_videos_folder = val_videos_folder
self.val_filter_videos_from_info_file = val_filter_videos_from_info_file
self.test_video_info_file_path = test_video_info_file_path
self.test_videos_folder = test_videos_folder
self.test_filter_videos_from_info_file = test_filter_videos_from_info_file
with open(cached_path(categories_file_path)) as file:
self.categories = {line.strip(): i for i, line in enumerate(file)}
@property
@overrides
def templates(self) -> Optional[Iterable[str]]:
return [ # From https://github.com/openai/CLIP/blob/main/data/prompts.md#kinetics700
"a photo of {}.",
"a photo of a person {}.",
"a photo of a person using {}.",
"a photo of a person doing {}.",
"a photo of a person during {}.",
"a photo of a person performing {}.",
"a photo of a person practicing {}.",
"a video of {}.",
"a video of a person {}.",
"a video of a person using {}.",
"a video of a person doing {}.",
"a video of a person during {}.",
"a video of a person performing {}.",
"a video of a person practicing {}.",
"a example of {}.",
"a example of a person {}.",
"a example of a person using {}.",
"a example of a person doing {}.",
"a example of a person during {}.",
"a example of a person performing {}.",
"a example of a person practicing {}.",
"a demonstration of {}.",
"a demonstration of a person {}.",
"a demonstration of a person using {}.",
"a demonstration of a person doing {}.",
"a demonstration of a person during {}.",
"a demonstration of a person performing {}.",
"a demonstration of a person practicing {}.",
]
def _dataset(self, video_info_file_path: TYPE_PATH, videos_folder: TYPE_PATH,
filter_videos_from_info_file: bool, train: bool) -> VideoDataset:
return Kinetics(self.categories, video_info_file_path=video_info_file_path, videos_folder=videos_folder,
filter_videos_from_info_file=filter_videos_from_info_file,
**self._create_dataset_encoder_kwargs(train=train))
@overrides
def train_dataloader(self) -> DataLoader:
dataset = self._dataset(video_info_file_path=self.train_video_info_file_path,
videos_folder=self.train_videos_folder,
filter_videos_from_info_file=self.train_filter_videos_from_info_file, train=True)
return self._create_dataloader(dataset, train=True)
@overrides
def val_dataloader(self) -> DataLoader:
dataset = self._dataset(video_info_file_path=self.val_video_info_file_path,
videos_folder=self.val_videos_folder,
filter_videos_from_info_file=self.val_filter_videos_from_info_file, train=False)
return self._create_dataloader(dataset, train=False)
@overrides
def test_dataloader(self) -> DataLoader:
dataset = self._dataset(video_info_file_path=self.test_video_info_file_path,
videos_folder=self.test_videos_folder,
filter_videos_from_info_file=self.test_filter_videos_from_info_file, train=False)
return self._create_dataloader(dataset, train=False)
| 6,115 | 49.131148 | 116 | py |
fitclip | fitclip-main/aligner/data/msrvtt.py | import json
import os
import random
from typing import Literal
import pandas as pd
from cached_path import cached_path
from overrides import overrides
from torch.utils.data import DataLoader
from aligner.data.video_data_module import VideoTextDataModule
from aligner.data.video_dataset import VideoDataset
from aligner.data.video_text_dataset import VideoTextDataset
from util.typing_utils import TYPE_PATH
from util.video_utils import get_sorted_videos_in_folder
TYPE_CAPTION_SAMPLING_STRATEGY = Literal["first", "random"]
class MsrVtt(VideoTextDataset):
def __init__(self, videos_folder: TYPE_PATH, file_list_path: TYPE_PATH, annotations_path: TYPE_PATH,
caption_sampling_strategy: TYPE_CAPTION_SAMPLING_STRATEGY, **kwargs) -> None:
with open(cached_path(file_list_path)) as file:
video_ids = {stripped_line for line in file if (stripped_line := line.strip())} # noqa
video_paths = (path
for path in get_sorted_videos_in_folder(cached_path(videos_folder))
if os.path.basename(path).split(".", maxsplit=1)[0] in video_ids)
super().__init__(video_paths=video_paths, **kwargs)
self.caption_sampling_strategy = caption_sampling_strategy
with open(cached_path(annotations_path)) as file:
metadata = json.load(file)
self.video_info = pd.DataFrame(metadata["annotations"])
self.video_info.set_index("image_id", inplace=True)
@overrides
def _get_target(self, video_idx: int) -> str:
video_id = self._get_video_id(video_idx)
captions = self.video_info.loc[video_id, "caption"]
if self.caption_sampling_strategy == "first":
return captions[0]
elif self.caption_sampling_strategy == "random":
return random.choice(captions)
else:
raise ValueError(f"Invalid choice of caption sampling strategy: {self.caption_sampling_strategy}")
class MsrVttDataModule(VideoTextDataModule): # noqa
def __init__(self,
base_path: TYPE_PATH = "https://www.robots.ox.ac.uk/~maxbain/frozen-in-time/data/MSRVTT.zip!MSRVTT/",
train_file_list_rel_path: TYPE_PATH = "train_list_jsfusion.txt", # 1K-A split
val_file_list_rel_path: TYPE_PATH = "val_list_jsfusion.txt", **kwargs) -> None:
super().__init__(**kwargs)
base_path = cached_path(base_path)
self.videos_folder = os.path.join(base_path, "videos/all")
self.annotation_path = os.path.join(base_path, "annotation/MSR_VTT.json")
self.train_file_list_path = os.path.join(base_path, "structured-symlinks", train_file_list_rel_path)
self.val_file_list_path = os.path.join(base_path, "structured-symlinks", val_file_list_rel_path)
def _dataset(self, file_list_path: TYPE_PATH, caption_sampling_strategy: TYPE_CAPTION_SAMPLING_STRATEGY,
train: bool) -> VideoDataset:
return MsrVtt(videos_folder=self.videos_folder, file_list_path=file_list_path,
annotations_path=self.annotation_path, caption_sampling_strategy=caption_sampling_strategy,
**self._create_dataset_encoder_kwargs(train=train))
@overrides
def train_dataloader(self) -> DataLoader:
dataset = self._dataset(file_list_path=self.train_file_list_path, caption_sampling_strategy="random",
train=True)
return self._create_dataloader(dataset, train=True)
@overrides
def val_dataloader(self) -> DataLoader:
dataset = self._dataset(file_list_path=self.val_file_list_path, caption_sampling_strategy="first", train=False)
return self._create_dataloader(dataset, train=False)
| 3,743 | 45.8 | 119 | py |
fitclip | fitclip-main/aligner/data/didemo.py | import json
import os
from collections import defaultdict
from cached_path import CACHE_DIR, _find_latest_cached, cached_path
from overrides import overrides
from torch.utils.data import DataLoader
from aligner.data.video_data_module import VideoTextDataModule
from aligner.data.video_text_dataset import VideoTextDataset
from util.typing_utils import TYPE_PATH
HASH_LIST_PATH = "https://raw.githubusercontent.com/LisaAnne/LocalizingMoments/master/data/yfcc100m_hash.txt"
VAL_ANNOTATION_PATH = "https://raw.githubusercontent.com/LisaAnne/LocalizingMoments/master/data/val_data.json"
VIDEOS_FOLDER = "https://multimedia-commons.s3-us-west-2.amazonaws.com/data/videos/mp4/"
class Didemo(VideoTextDataset):
def __init__(self, videos_folder: TYPE_PATH, hash_list_path: TYPE_PATH, annotations_path: TYPE_PATH,
**kwargs) -> None:
with open(cached_path(annotations_path)) as file:
description_list_by_id = defaultdict(list)
for video in json.load(file):
description_list_by_id[video["video"]].append(video["description"])
self.description_paragraph_by_id = {video_id: " ".join(descriptions)
for video_id, descriptions in description_list_by_id.items()}
with open(cached_path(hash_list_path)) as file:
hash_by_flickr_id = {}
for line in file:
flickr_id, hash_ = line.strip().split("\t")
hash_by_flickr_id[flickr_id] = hash_
self.video_ids_by_path = {}
for video_id in self.description_paragraph_by_id:
flickr_id = video_id.split("_")[1]
hash_ = hash_by_flickr_id[flickr_id]
video_path_or_url = os.path.join(videos_folder, hash_[:3], hash_[3:6], f"{hash_}.mp4")
# We only download some videos and not the whole folder.
# But if it's already cached, we avoid sending a HEAD request. This is an issue if the file is updated,
# but we assume it won't happen.
video_path = _find_latest_cached(video_path_or_url, CACHE_DIR) or cached_path(video_path_or_url)
self.video_ids_by_path[video_path] = video_id
super().__init__(video_paths=self.video_ids_by_path.keys(), **kwargs)
@overrides
def _get_target(self, video_idx: int) -> str:
video_path = self.video_paths[video_idx]
video_id = self.video_ids_by_path[video_path]
return self.description_paragraph_by_id[video_id]
class DidemoDataModule(VideoTextDataModule): # noqa
def __init__(self, videos_folder: TYPE_PATH = VIDEOS_FOLDER, hash_list_path: TYPE_PATH = HASH_LIST_PATH,
val_annotation_path: TYPE_PATH = VAL_ANNOTATION_PATH, **kwargs) -> None:
super().__init__(**kwargs)
self.videos_folder = videos_folder
self.hash_list_path = hash_list_path
self.val_annotation_path = val_annotation_path
@overrides
def val_dataloader(self) -> DataLoader:
dataset = Didemo(videos_folder=self.videos_folder, hash_list_path=self.hash_list_path,
annotations_path=self.val_annotation_path, **self._create_dataset_encoder_kwargs(train=False))
return self._create_dataloader(dataset, train=False)
| 3,269 | 47.088235 | 119 | py |
fitclip | fitclip-main/aligner/data/conceptual_captions.py | import functools
import os
import pandas as pd
from cached_path import cached_path
from overrides import overrides
from torch.utils.data import DataLoader
from torchvision.datasets.folder import IMG_EXTENSIONS
from aligner.data.video_data_module import VideoTextDataModule
from aligner.data.video_dataset import VideoDataset
from aligner.data.video_text_dataset import VideoTextDataset
from util.typing_utils import TYPE_PATH
from util.video_utils import get_videos_in_folder
class ConceptualCaptions(VideoTextDataset):
def __init__(self, video_info_file_path: TYPE_PATH, videos_folder: TYPE_PATH, **kwargs) -> None:
self.video_info = pd.read_csv(cached_path(video_info_file_path), names=["name", "url", "video_id"],
index_col="video_id")
# The version of CC3M used here was downloaded by keeping the original filenames. The issue is that the
# filenames repeat, and only one of the files was kept, but we don't know which one it is from the
# information file with the captions. So as a workaround, we remove the duplicate video IDs:
self.video_info = self.video_info[~self.video_info.index.duplicated(keep=False)]
video_paths = sorted(path
for path in get_videos_in_folder(cached_path(videos_folder), extensions=IMG_EXTENSIONS)
if os.path.basename(path) in self.video_info.index)
super().__init__(video_paths=video_paths, **kwargs)
@functools.lru_cache
@overrides
def _get_video_id(self, video_idx: int) -> str:
return os.path.basename(self.video_paths[video_idx])
@overrides
def _get_target(self, video_idx: int) -> str:
video_id = self._get_video_id(video_idx)
return self.video_info.loc[video_id, "name"]
class ConceptualCaptionsDataModule(VideoTextDataModule): # noqa
def __init__(self, train_video_info_file_path: TYPE_PATH, train_videos_folder: TYPE_PATH,
val_video_info_file_path: TYPE_PATH, val_videos_folder: TYPE_PATH, **kwargs) -> None:
super().__init__(**kwargs)
self.train_video_info_file_path = train_video_info_file_path
self.train_videos_folder = train_videos_folder
self.val_video_info_file_path = val_video_info_file_path
self.val_videos_folder = val_videos_folder
def _dataset(self, video_info_file_path: TYPE_PATH, videos_folder: TYPE_PATH, train: bool) -> VideoDataset:
return ConceptualCaptions(video_info_file_path=video_info_file_path, videos_folder=videos_folder,
**self._create_dataset_encoder_kwargs(train=train))
@overrides
def train_dataloader(self) -> DataLoader:
dataset = self._dataset(video_info_file_path=self.train_video_info_file_path,
videos_folder=self.train_videos_folder, train=True)
return self._create_dataloader(dataset, train=True)
@overrides
def val_dataloader(self) -> DataLoader:
dataset = self._dataset(video_info_file_path=self.val_video_info_file_path,
videos_folder=self.val_videos_folder, train=False)
return self._create_dataloader(dataset, train=False)
| 3,241 | 48.121212 | 116 | py |
fitclip | fitclip-main/aligner/data/ucf.py | import functools
import os
import re
from typing import Iterable, Mapping, Optional, Tuple
from cached_path import cached_path
from overrides import overrides
from torch.utils.data import DataLoader
from aligner.data.video_data_module import VideoClassificationDataModule
from aligner.data.video_dataset import VideoDataset
from util.typing_utils import TYPE_PATH
CATEGORIES_FILE_PATH = ("https://www.crcv.ucf.edu/data/UCF101/UCF101TrainTestSplits-RecognitionTask.zip!"
"ucfTrainTestlist/classInd.txt")
VAL_FILE_LIST_PATH = ("https://www.crcv.ucf.edu/data/UCF101/UCF101TrainTestSplits-RecognitionTask.zip!"
"ucfTrainTestlist/testlist01.txt")
VAL_VIDEOS_FOLDER = "https://www.crcv.ucf.edu/data/UCF101/UCF101.rar!UCF-101"
RE_CAPITALIZED_WORDS = re.compile(r"[a-zA-Z][^A-Z]*")
UCF_101_TEMPLATES = [ # From https://github.com/openai/CLIP/blob/main/data/prompts.md#ucf101
"a photo of a person {}.",
"a video of a person {}.",
"a example of a person {}.",
"a demonstration of a person {}.",
"a photo of the person {}.",
"a video of the person {}.",
"a example of the person {}.",
"a demonstration of the person {}.",
"a photo of a person using {}.",
"a video of a person using {}.",
"a example of a person using {}.",
"a demonstration of a person using {}.",
"a photo of the person using {}.",
"a video of the person using {}.",
"a example of the person using {}.",
"a demonstration of the person using {}.",
"a photo of a person doing {}.",
"a video of a person doing {}.",
"a example of a person doing {}.",
"a demonstration of a person doing {}.",
"a photo of the person doing {}.",
"a video of the person doing {}.",
"a example of the person doing {}.",
"a demonstration of the person doing {}.",
"a photo of a person during {}.",
"a video of a person during {}.",
"a example of a person during {}.",
"a demonstration of a person during {}.",
"a photo of the person during {}.",
"a video of the person during {}.",
"a example of the person during {}.",
"a demonstration of the person during {}.",
"a photo of a person performing {}.",
"a video of a person performing {}.",
"a example of a person performing {}.",
"a demonstration of a person performing {}.",
"a photo of the person performing {}.",
"a video of the person performing {}.",
"a example of the person performing {}.",
"a demonstration of the person performing {}.",
"a photo of a person practicing {}.",
"a video of a person practicing {}.",
"a example of a person practicing {}.",
"a demonstration of a person practicing {}.",
"a photo of the person practicing {}.",
"a video of the person practicing {}.",
"a example of the person practicing {}.",
"a demonstration of the person practicing {}.",
]
def _folder_name_to_category(folder_name: str) -> str:
return " ".join(RE_CAPITALIZED_WORDS.findall(folder_name))
class Ucf(VideoDataset):
def __init__(self, categories: Mapping[str, int], file_list_path: TYPE_PATH, videos_folder: TYPE_PATH,
**kwargs) -> None:
self.categories = categories
videos_folder = cached_path(videos_folder)
with open(cached_path(file_list_path)) as file:
video_ids = (stripped_line for line in file if (stripped_line := line.strip()))
super().__init__(video_paths=(os.path.join(videos_folder, path) for path in video_ids), **kwargs)
@functools.lru_cache
@overrides
def _get_video_id(self, video_idx: int) -> str:
path = self.video_paths[video_idx]
folder_path, filename = os.path.split(path)
folder_name = os.path.basename(folder_path)
return os.path.join(folder_name, filename)
@functools.lru_cache
@overrides
def _get_target(self, video_idx: int) -> Tuple[str, int]:
video_id = self._get_video_id(video_idx)
folder_name = os.path.dirname(video_id)
category = _folder_name_to_category(folder_name)
return category, self.categories[category]
class UcfDataModule(VideoClassificationDataModule): # noqa
categories = {} # Necessary because it's an abstract property. See https://stackoverflow.com/a/42529760/1165181
def __init__(self, categories_file_path: TYPE_PATH = CATEGORIES_FILE_PATH,
val_file_list_path: TYPE_PATH = VAL_FILE_LIST_PATH,
val_videos_folder: TYPE_PATH = VAL_VIDEOS_FOLDER, **kwargs) -> None:
super().__init__(**kwargs)
self.val_file_list_path = val_file_list_path
self.val_videos_folder = val_videos_folder
with open(cached_path(categories_file_path)) as file:
self.categories = {}
for line in file:
id_, folder_name = line.strip().split()
self.categories[_folder_name_to_category(folder_name)] = int(id_) - 1
@property
@overrides
def templates(self) -> Optional[Iterable[str]]:
return UCF_101_TEMPLATES
@overrides
def val_dataloader(self) -> DataLoader:
dataset = Ucf(categories=self.categories, file_list_path=self.val_file_list_path,
videos_folder=self.val_videos_folder, **self._create_dataset_encoder_kwargs(train=False))
return self._create_dataloader(dataset, train=False)
| 5,400 | 40.229008 | 116 | py |
VQ-Diffusion | VQ-Diffusion-main/inference_VQ_Diffusion.py | # ------------------------------------------
# VQ-Diffusion
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
# written By Shuyang Gu
# ------------------------------------------
import os
import sys
sys.path.append(os.path.join(os.path.dirname(__file__), '../'))
import torch
import cv2
import argparse
import numpy as np
import torchvision
from PIL import Image
from image_synthesis.utils.io import load_yaml_config
from image_synthesis.modeling.build import build_model
from image_synthesis.utils.misc import get_model_parameters_info
class VQ_Diffusion():
def __init__(self, config, path, imagenet_cf=False):
self.info = self.get_model(ema=True, model_path=path, config_path=config, imagenet_cf=imagenet_cf)
self.model = self.info['model']
self.epoch = self.info['epoch']
self.model_name = self.info['model_name']
self.model = self.model.cuda()
self.model.eval()
for param in self.model.parameters():
param.requires_grad=False
def get_model(self, ema, model_path, config_path, imagenet_cf):
if 'OUTPUT' in model_path: # pretrained model
model_name = model_path.split(os.path.sep)[-3]
else:
model_name = os.path.basename(config_path).replace('.yaml', '')
config = load_yaml_config(config_path)
if imagenet_cf:
config['model']['params']['diffusion_config']['params']['transformer_config']['params']['class_number'] = 1001
model = build_model(config)
model_parameters = get_model_parameters_info(model)
print(model_parameters)
if os.path.exists(model_path):
ckpt = torch.load(model_path, map_location="cpu")
else:
print("Model path: {} does not exist.".format(model_path))
exit(0)
if 'last_epoch' in ckpt:
epoch = ckpt['last_epoch']
elif 'epoch' in ckpt:
epoch = ckpt['epoch']
else:
epoch = 0
missing, unexpected = model.load_state_dict(ckpt["model"], strict=False)
print('Model missing keys:\n', missing)
print('Model unexpected keys:\n', unexpected)
if ema==True and 'ema' in ckpt:
print("Evaluate EMA model")
ema_model = model.get_ema_model()
missing, unexpected = ema_model.load_state_dict(ckpt['ema'], strict=False)
return {'model': model, 'epoch': epoch, 'model_name': model_name, 'parameter': model_parameters}
def inference_generate_sample_with_class(self, text, truncation_rate, save_root, batch_size, infer_speed=False, guidance_scale=1.0):
os.makedirs(save_root, exist_ok=True)
self.model.guidance_scale = guidance_scale
data_i = {}
data_i['label'] = [text]
data_i['image'] = None
condition = text
str_cond = str(condition)
save_root_ = os.path.join(save_root, str_cond)
os.makedirs(save_root_, exist_ok=True)
with torch.no_grad():
model_out = self.model.generate_content(
batch=data_i,
filter_ratio=0,
replicate=batch_size,
content_ratio=1,
return_att_weight=False,
sample_type="top"+str(truncation_rate)+'r',
) # B x C x H x W
# save results
content = model_out['content']
content = content.permute(0, 2, 3, 1).to('cpu').numpy().astype(np.uint8)
for b in range(content.shape[0]):
cnt = b
save_base_name = '{}'.format(str(cnt).zfill(6))
save_path = os.path.join(save_root_, save_base_name+'.jpg')
im = Image.fromarray(content[b])
im.save(save_path)
def inference_generate_sample_with_condition(self, text, truncation_rate, save_root, batch_size, infer_speed=False, guidance_scale=1.0, prior_rule=0, prior_weight=0, learnable_cf=True):
os.makedirs(save_root, exist_ok=True)
self.model.guidance_scale = guidance_scale
self.model.learnable_cf = self.model.transformer.learnable_cf = learnable_cf # whether to use learnable classifier-free
self.model.transformer.prior_rule = prior_rule # inference rule: 0 for VQ-Diffusion v1, 1 for only high-quality inference, 2 for purity prior
self.model.transformer.prior_weight = prior_weight # probability adjust parameter, 'r' in Equation.11 of Improved VQ-Diffusion
data_i = {}
data_i['text'] = [text]
data_i['image'] = None
condition = text
str_cond = str(condition)
save_root_ = os.path.join(save_root, str_cond)
os.makedirs(save_root_, exist_ok=True)
if infer_speed != False:
add_string = 'r,time'+str(infer_speed)
else:
add_string = 'r'
with torch.no_grad():
model_out = self.model.generate_content(
batch=data_i,
filter_ratio=0,
replicate=batch_size,
content_ratio=1,
return_att_weight=False,
sample_type="top"+str(truncation_rate)+add_string,
) # B x C x H x W
# save results
content = model_out['content']
content = content.permute(0, 2, 3, 1).to('cpu').numpy().astype(np.uint8)
for b in range(content.shape[0]):
cnt = b
save_base_name = '{}'.format(str(cnt).zfill(6))
save_path = os.path.join(save_root_, save_base_name+'.png')
im = Image.fromarray(content[b])
im.save(save_path)
if __name__ == '__main__':
VQ_Diffusion_model = VQ_Diffusion(config='configs/ithq.yaml', path='OUTPUT/pretrained_model/ithq_learnable.pth')
# Inference VQ-Diffusion
# VQ_Diffusion_model.inference_generate_sample_with_condition("teddy bear playing in the pool", truncation_rate=0.86, save_root="RESULT", batch_size=4)
# Inference Improved VQ-Diffusion with zero-shot classifier-free sampling
# VQ_Diffusion_model.inference_generate_sample_with_condition("teddy bear playing in the pool", truncation_rate=1.0, save_root="RESULT", batch_size=4, guidance_scale=5.0, learnable_cf=False)
# VQ_Diffusion_model.inference_generate_sample_with_condition("a long exposure photo of waterfall", truncation_rate=1.0, save_root="RESULT", batch_size=4, guidance_scale=5.0, learnable_cf=False)
# Inference Improved VQ-Diffusion with learnable classifier-free sampling
VQ_Diffusion_model.inference_generate_sample_with_condition("teddy bear playing in the pool", truncation_rate=1.0, save_root="RESULT", batch_size=4, guidance_scale=5.0)
# VQ_Diffusion_model.inference_generate_sample_with_condition("a long exposure photo of waterfall", truncation_rate=1.0, save_root="RESULT", batch_size=4, guidance_scale=5.0)
# Inference Improved VQ-Diffusion with fast/high-quality inference
# VQ_Diffusion_model.inference_generate_sample_with_condition("a long exposure photo of waterfall", truncation_rate=0.86, save_root="RESULT", batch_size=4, infer_speed=0.5) # high-quality inference, 0.5x inference speed
# VQ_Diffusion_model.inference_generate_sample_with_condition("a long exposure photo of waterfall", truncation_rate=0.86, save_root="RESULT", batch_size=4, infer_speed=2) # fast inference, 2x inference speed
# infer_speed shoule be float in [0.1, 10], larger infer_speed means faster inference and smaller infer_speed means slower inference
# Inference Improved VQ-Diffusion with purity sampling
# VQ_Diffusion_model.inference_generate_sample_with_condition("a long exposure photo of waterfall", truncation_rate=0.86, save_root="RESULT", batch_size=4, prior_rule=2, prior_weight=1) # purity sampling
# Inference Improved VQ-Diffusion with both learnable classifier-free sampling and fast inference
# VQ_Diffusion_model.inference_generate_sample_with_condition("a long exposure photo of waterfall", truncation_rate=1.0, save_root="RESULT", batch_size=4, guidance_scale=5.0, infer_speed=2) # classifier-free guidance and fast inference
# VQ_Diffusion_model = VQ_Diffusion(config='OUTPUT/pretrained_model/config_text.yaml', path='OUTPUT/pretrained_model/coco_learnable.pth')
# Inference VQ-Diffusion
# VQ_Diffusion_model.inference_generate_sample_with_condition("A group of elephants walking in muddy water", truncation_rate=0.86, save_root="RESULT", batch_size=4)
# Inference Improved VQ-Diffusion with learnable classifier-free sampling
# VQ_Diffusion_model.inference_generate_sample_with_condition("A group of elephants walking in muddy water", truncation_rate=1.0, save_root="RESULT", batch_size=4, guidance_scale=3.0)
# Inference Improved VQ-Diffusion with zero-shot classifier-free sampling: load models without classifier-free fine-tune and set guidance_scale to > 1
# VQ_Diffusion_model = VQ_Diffusion(config='OUTPUT/pretrained_model/config_text.yaml', path='OUTPUT/pretrained_model/coco_pretrained.pth')
# VQ_Diffusion_model.inference_generate_sample_with_condition("A group of elephants walking in muddy water", truncation_rate=0.86, save_root="RESULT", batch_size=4, guidance_scale=3.0, learnable_cf=False)
# Inference VQ-Diffusion
# VQ_Diffusion_model = VQ_Diffusion(config='OUTPUT/pretrained_model/config_imagenet.yaml', path='OUTPUT/pretrained_model/imagenet_pretrained.pth')
# VQ_Diffusion_model.inference_generate_sample_with_class(407, truncation_rate=0.86, save_root="RESULT", batch_size=4)
# Inference Improved VQ-Diffusion with classifier-free sampling
# VQ_Diffusion_model = VQ_Diffusion(config='configs/imagenet.yaml', path='OUTPUT/pretrained_model/imagenet_learnable.pth', imagenet_cf=True)
# VQ_Diffusion_model.inference_generate_sample_with_class(407, truncation_rate=0.94, save_root="RESULT", batch_size=4, guidance_scale=1.5)
| 9,903 | 48.029703 | 239 | py |
VQ-Diffusion | VQ-Diffusion-main/train.py | # ------------------------------------------
# VQ-Diffusion
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
# written By Shuyang Gu
# ------------------------------------------
import argparse
import os
import warnings
import time
import torch
from image_synthesis.modeling.build import build_model
from image_synthesis.data.build import build_dataloader
from image_synthesis.utils.misc import seed_everything, merge_opts_to_config, modify_config_for_debug
from image_synthesis.utils.io import load_yaml_config
from image_synthesis.engine.logger import Logger
from image_synthesis.engine.solver import Solver
from image_synthesis.distributed.launch import launch
# environment variables
NODE_RANK = os.environ['AZ_BATCHAI_TASK_INDEX'] if 'AZ_BATCHAI_TASK_INDEX' in os.environ else 0
NODE_RANK = int(NODE_RANK)
MASTER_ADDR, MASTER_PORT = os.environ['AZ_BATCH_MASTER_NODE'].split(':') if 'AZ_BATCH_MASTER_NODE' in os.environ else ("127.0.0.1", 29500)
MASTER_PORT = int(MASTER_PORT)
DIST_URL = 'tcp://%s:%s' % (MASTER_ADDR, MASTER_PORT)
def get_args():
parser = argparse.ArgumentParser(description='PyTorch Training script')
parser.add_argument('--config_file', type=str, default='configs/vqvae_celeba_attribute_cond.yaml',
help='path of config file')
parser.add_argument('--name', type=str, default='',
help='the name of this experiment, if not provided, set to'
'the name of config file')
parser.add_argument('--output', type=str, default='OUTPUT',
help='directory to save the results')
parser.add_argument('--log_frequency', type=int, default=100,
help='print frequency (default: 100)')
parser.add_argument('--load_path', type=str, default=None,
help='path to model that need to be loaded, '
'used for loading pretrained model')
parser.add_argument('--resume_name', type=str, default=None,
help='resume one experiment with the given name')
parser.add_argument('--auto_resume', action='store_true',
help='automatically resume the training')
# args for ddp
parser.add_argument('--num_node', type=int, default=1,
help='number of nodes for distributed training')
parser.add_argument('--node_rank', type=int, default=NODE_RANK,
help='node rank for distributed training')
parser.add_argument('--dist_url', type=str, default=DIST_URL,
help='url used to set up distributed training')
parser.add_argument('--gpu', type=int, default=None,
help='GPU id to use. If given, only the specific gpu will be'
' used, and ddp will be disabled')
parser.add_argument('--sync_bn', action='store_true',
help='use sync BN layer')
parser.add_argument('--tensorboard', action='store_true',
help='use tensorboard for logging')
parser.add_argument('--timestamp', action='store_true', # default=True,
help='use tensorboard for logging')
# args for random
parser.add_argument('--seed', type=int, default=None,
help='seed for initializing training. ')
parser.add_argument('--cudnn_deterministic', action='store_true',
help='set cudnn.deterministic True')
parser.add_argument('--amp', action='store_true', # default=True,
help='automatic mixture of precesion')
parser.add_argument('--debug', action='store_true', default=False,
help='set as debug mode')
# args for modify config
parser.add_argument(
"opts",
help="Modify config options using the command-line",
default=None,
nargs=argparse.REMAINDER,
)
args = parser.parse_args()
args.cwd = os.path.abspath(os.path.dirname(__file__))
if args.resume_name is not None:
args.name = args.resume_name
args.config_file = os.path.join(args.output, args.resume_name, 'configs', 'config.yaml')
args.auto_resume = True
else:
if args.name == '':
args.name = os.path.basename(args.config_file).replace('.yaml', '')
if args.timestamp:
assert not args.auto_resume, "for timstamp, auto resume is hard to find the save directory"
time_str = time.strftime('%Y-%m-%d-%H-%M')
args.name = time_str + '-' + args.name
# modify args for debugging
if args.debug:
args.name = 'debug'
if args.gpu is None:
args.gpu = 0
args.save_dir = os.path.join(args.output, args.name)
return args
def main():
args = get_args()
if args.seed is not None or args.cudnn_deterministic:
seed_everything(args.seed, args.cudnn_deterministic)
if args.gpu is not None:
warnings.warn('You have chosen a specific GPU. This will completely disable ddp.')
torch.cuda.set_device(args.gpu)
args.ngpus_per_node = 1
args.world_size = 1
else:
if args.num_node == 1:
args.dist_url == "auto"
else:
assert args.num_node > 1
args.ngpus_per_node = torch.cuda.device_count()
args.world_size = args.ngpus_per_node * args.num_node
launch(main_worker, args.ngpus_per_node, args.num_node, args.node_rank, args.dist_url, args=(args,))
def main_worker(local_rank, args):
args.local_rank = local_rank
args.global_rank = args.local_rank + args.node_rank * args.ngpus_per_node
args.distributed = args.world_size > 1
# load config
config = load_yaml_config(args.config_file)
config = merge_opts_to_config(config, args.opts)
if args.debug:
config = modify_config_for_debug(config)
# get logger
logger = Logger(args)
logger.save_config(config)
# get model
model = build_model(config, args)
# print(model)
if args.sync_bn:
model = torch.nn.SyncBatchNorm.convert_sync_batchnorm(model)
# get dataloader
dataloader_info = build_dataloader(config, args)
# get solver
solver = Solver(config=config, args=args, model=model, dataloader=dataloader_info, logger=logger)
# resume
if args.load_path is not None: # only load the model paramters
solver.resume(path=args.load_path,
# load_model=True,
load_optimizer_and_scheduler=False,
load_others=False)
if args.auto_resume:
solver.resume()
# with torch.autograd.set_detect_anomaly(True):
# solver.train()
solver.train()
if __name__ == '__main__':
main()
| 6,809 | 39.058824 | 138 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/distributed/launch.py | import os
import torch
from torch import distributed as dist
from torch import multiprocessing as mp
# import distributed as dist_fn
import image_synthesis.distributed.distributed as dist_fn
def find_free_port():
import socket
sock = socket.socket(socket.AF_INET, socket.SOCK_STREAM)
sock.bind(("", 0))
port = sock.getsockname()[1]
sock.close()
return port
def launch(fn, n_gpu_per_machine, n_machine=1, machine_rank=0, dist_url=None, args=()):
world_size = n_machine * n_gpu_per_machine
if world_size > 1:
# if "OMP_NUM_THREADS" not in os.environ:
# os.environ["OMP_NUM_THREADS"] = "1"
if dist_url == "auto":
if n_machine != 1:
raise ValueError('dist_url="auto" not supported in multi-machine jobs')
port = find_free_port()
dist_url = f"tcp://127.0.0.1:{port}"
if n_machine > 1 and dist_url.startswith("file://"):
raise ValueError(
"file:// is not a reliable init method in multi-machine jobs. Prefer tcp://"
)
mp.spawn(
distributed_worker,
nprocs=n_gpu_per_machine,
args=(fn, world_size, n_gpu_per_machine, machine_rank, dist_url, args),
daemon=False,
)
else:
local_rank = 0
fn(local_rank, *args)
def distributed_worker(
local_rank, fn, world_size, n_gpu_per_machine, machine_rank, dist_url, args
):
if not torch.cuda.is_available():
raise OSError("CUDA is not available. Please check your environments")
global_rank = machine_rank * n_gpu_per_machine + local_rank
try:
dist.init_process_group(
backend="NCCL",
init_method=dist_url,
world_size=world_size,
rank=global_rank,
)
except Exception:
raise OSError("failed to initialize NCCL groups")
dist_fn.synchronize()
if n_gpu_per_machine > torch.cuda.device_count():
raise ValueError(
f"specified n_gpu_per_machine larger than available device ({torch.cuda.device_count()})"
)
torch.cuda.set_device(local_rank)
if dist_fn.LOCAL_PROCESS_GROUP is not None:
raise ValueError("torch.distributed.LOCAL_PROCESS_GROUP is not None")
n_machine = world_size // n_gpu_per_machine
for i in range(n_machine):
ranks_on_i = list(range(i * n_gpu_per_machine, (i + 1) * n_gpu_per_machine))
pg = dist.new_group(ranks_on_i)
if i == machine_rank:
dist_fn.LOCAL_PROCESS_GROUP = pg
fn(local_rank, *args)
| 2,604 | 26.712766 | 101 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/distributed/distributed.py | import math
import pickle
import torch
from torch import distributed as dist
from torch.utils import data
LOCAL_PROCESS_GROUP = None
def is_primary():
return get_rank() == 0
def get_rank():
if not dist.is_available():
return 0
if not dist.is_initialized():
return 0
return dist.get_rank()
def get_local_rank():
if not dist.is_available():
return 0
if not dist.is_initialized():
return 0
if LOCAL_PROCESS_GROUP is None:
raise ValueError("tensorfn.distributed.LOCAL_PROCESS_GROUP is None")
return dist.get_rank(group=LOCAL_PROCESS_GROUP)
def synchronize():
if not dist.is_available():
return
if not dist.is_initialized():
return
world_size = dist.get_world_size()
if world_size == 1:
return
dist.barrier()
def get_world_size():
if not dist.is_available():
return 1
if not dist.is_initialized():
return 1
return dist.get_world_size()
def is_distributed():
raise RuntimeError('Please debug this function!')
return get_world_size() > 1
def all_reduce(tensor, op=dist.ReduceOp.SUM, async_op=False):
world_size = get_world_size()
if world_size == 1:
return tensor
dist.all_reduce(tensor, op=op, async_op=async_op)
return tensor
def all_gather(data):
world_size = get_world_size()
if world_size == 1:
return [data]
buffer = pickle.dumps(data)
storage = torch.ByteStorage.from_buffer(buffer)
tensor = torch.ByteTensor(storage).to("cuda")
local_size = torch.IntTensor([tensor.numel()]).to("cuda")
size_list = [torch.IntTensor([1]).to("cuda") for _ in range(world_size)]
dist.all_gather(size_list, local_size)
size_list = [int(size.item()) for size in size_list]
max_size = max(size_list)
tensor_list = []
for _ in size_list:
tensor_list.append(torch.ByteTensor(size=(max_size,)).to("cuda"))
if local_size != max_size:
padding = torch.ByteTensor(size=(max_size - local_size,)).to("cuda")
tensor = torch.cat((tensor, padding), 0)
dist.all_gather(tensor_list, tensor)
data_list = []
for size, tensor in zip(size_list, tensor_list):
buffer = tensor.cpu().numpy().tobytes()[:size]
data_list.append(pickle.loads(buffer))
return data_list
def reduce_dict(input_dict, average=True):
world_size = get_world_size()
if world_size < 2:
return input_dict
with torch.no_grad():
keys = []
values = []
for k in sorted(input_dict.keys()):
keys.append(k)
values.append(input_dict[k])
values = torch.stack(values, 0)
dist.reduce(values, dst=0)
if dist.get_rank() == 0 and average:
values /= world_size
reduced_dict = {k: v for k, v in zip(keys, values)}
return reduced_dict
def data_sampler(dataset, shuffle, distributed):
if distributed:
return data.distributed.DistributedSampler(dataset, shuffle=shuffle)
if shuffle:
return data.RandomSampler(dataset)
else:
return data.SequentialSampler(dataset)
| 3,169 | 20.418919 | 76 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/engine/lr_scheduler.py | import torch
import math
# from torch.optim import AdamW, Adam
from torch._six import inf
from torch.optim.optimizer import Optimizer
from torch.optim.lr_scheduler import _LRScheduler, CosineAnnealingLR
class ReduceLROnPlateauWithWarmup(object):
"""Reduce learning rate when a metric has stopped improving.
Models often benefit from reducing the learning rate by a factor
of 2-10 once learning stagnates. This scheduler reads a metrics
quantity and if no improvement is seen for a 'patience' number
of epochs, the learning rate is reduced.
Args:
optimizer (Optimizer): Wrapped optimizer.
mode (str): One of `min`, `max`. In `min` mode, lr will
be reduced when the quantity monitored has stopped
decreasing; in `max` mode it will be reduced when the
quantity monitored has stopped increasing. Default: 'min'.
factor (float): Factor by which the learning rate will be
reduced. new_lr = lr * factor. Default: 0.1.
patience (int): Number of epochs with no improvement after
which learning rate will be reduced. For example, if
`patience = 2`, then we will ignore the first 2 epochs
with no improvement, and will only decrease the LR after the
3rd epoch if the loss still hasn't improved then.
Default: 10.
threshold (float): Threshold for measuring the new optimum,
to only focus on significant changes. Default: 1e-4.
threshold_mode (str): One of `rel`, `abs`. In `rel` mode,
dynamic_threshold = best * ( 1 + threshold ) in 'max'
mode or best * ( 1 - threshold ) in `min` mode.
In `abs` mode, dynamic_threshold = best + threshold in
`max` mode or best - threshold in `min` mode. Default: 'rel'.
cooldown (int): Number of epochs to wait before resuming
normal operation after lr has been reduced. Default: 0.
min_lr (float or list): A scalar or a list of scalars. A
lower bound on the learning rate of all param groups
or each group respectively. Default: 0.
eps (float): Minimal decay applied to lr. If the difference
between new and old lr is smaller than eps, the update is
ignored. Default: 1e-8.
verbose (bool): If ``True``, prints a message to stdout for
each update. Default: ``False``.
warmup_lr: float or None, the learning rate to be touched after warmup
warmup: int, the number of steps to warmup
"""
def __init__(self, optimizer, mode='min', factor=0.1, patience=10,
threshold=1e-4, threshold_mode='rel', cooldown=0,
min_lr=0, eps=1e-8, verbose=False, warmup_lr=None,
warmup=0):
if factor >= 1.0:
raise ValueError('Factor should be < 1.0.')
self.factor = factor
# Attach optimizer
if not isinstance(optimizer, Optimizer):
raise TypeError('{} is not an Optimizer'.format(
type(optimizer).__name__))
self.optimizer = optimizer
if isinstance(min_lr, list) or isinstance(min_lr, tuple):
if len(min_lr) != len(optimizer.param_groups):
raise ValueError("expected {} min_lrs, got {}".format(
len(optimizer.param_groups), len(min_lr)))
self.min_lrs = list(min_lr)
else:
self.min_lrs = [min_lr] * len(optimizer.param_groups)
self.patience = patience
self.verbose = verbose
self.cooldown = cooldown
self.cooldown_counter = 0
self.mode = mode
self.threshold = threshold
self.threshold_mode = threshold_mode
self.warmup_lr = warmup_lr
self.warmup = warmup
self.best = None
self.num_bad_epochs = None
self.mode_worse = None # the worse value for the chosen mode
self.eps = eps
self.last_epoch = 0
self._init_is_better(mode=mode, threshold=threshold,
threshold_mode=threshold_mode)
self._reset()
def _prepare_for_warmup(self):
if self.warmup_lr is not None:
if isinstance(self.warmup_lr, (list, tuple)):
if len(self.warmup_lr) != len(self.optimizer.param_groups):
raise ValueError("expected {} warmup_lrs, got {}".format(
len(self.optimizer.param_groups), len(self.warmup_lr)))
self.warmup_lrs = list(self.warmup_lr)
else:
self.warmup_lrs = [self.warmup_lr] * len(self.optimizer.param_groups)
else:
self.warmup_lrs = None
if self.warmup > self.last_epoch:
curr_lrs = [group['lr'] for group in self.optimizer.param_groups]
self.warmup_lr_steps = [max(0, (self.warmup_lrs[i] - curr_lrs[i])/float(self.warmup)) for i in range(len(curr_lrs))]
else:
self.warmup_lr_steps = None
def _reset(self):
"""Resets num_bad_epochs counter and cooldown counter."""
self.best = self.mode_worse
self.cooldown_counter = 0
self.num_bad_epochs = 0
def step(self, metrics):
# convert `metrics` to float, in case it's a zero-dim Tensor
current = float(metrics)
epoch = self.last_epoch + 1
self.last_epoch = epoch
if epoch <= self.warmup:
self._increase_lr(epoch)
else:
if self.is_better(current, self.best):
self.best = current
self.num_bad_epochs = 0
else:
self.num_bad_epochs += 1
if self.in_cooldown:
self.cooldown_counter -= 1
self.num_bad_epochs = 0 # ignore any bad epochs in cooldown
if self.num_bad_epochs > self.patience:
self._reduce_lr(epoch)
self.cooldown_counter = self.cooldown
self.num_bad_epochs = 0
self._last_lr = [group['lr'] for group in self.optimizer.param_groups]
def _reduce_lr(self, epoch):
for i, param_group in enumerate(self.optimizer.param_groups):
old_lr = float(param_group['lr'])
new_lr = max(old_lr * self.factor, self.min_lrs[i])
if old_lr - new_lr > self.eps:
param_group['lr'] = new_lr
if self.verbose:
print('Epoch {:5d}: reducing learning rate'
' of group {} to {:.4e}.'.format(epoch, i, new_lr))
def _increase_lr(self, epoch):
# used for warmup
for i, param_group in enumerate(self.optimizer.param_groups):
old_lr = float(param_group['lr'])
new_lr = max(old_lr + self.warmup_lr_steps[i], self.min_lrs[i])
param_group['lr'] = new_lr
if self.verbose:
print('Epoch {:5d}: increasing learning rate'
' of group {} to {:.4e}.'.format(epoch, i, new_lr))
@property
def in_cooldown(self):
return self.cooldown_counter > 0
def is_better(self, a, best):
if self.mode == 'min' and self.threshold_mode == 'rel':
rel_epsilon = 1. - self.threshold
return a < best * rel_epsilon
elif self.mode == 'min' and self.threshold_mode == 'abs':
return a < best - self.threshold
elif self.mode == 'max' and self.threshold_mode == 'rel':
rel_epsilon = self.threshold + 1.
return a > best * rel_epsilon
else: # mode == 'max' and epsilon_mode == 'abs':
return a > best + self.threshold
def _init_is_better(self, mode, threshold, threshold_mode):
if mode not in {'min', 'max'}:
raise ValueError('mode ' + mode + ' is unknown!')
if threshold_mode not in {'rel', 'abs'}:
raise ValueError('threshold mode ' + threshold_mode + ' is unknown!')
if mode == 'min':
self.mode_worse = inf
else: # mode == 'max':
self.mode_worse = -inf
self.mode = mode
self.threshold = threshold
self.threshold_mode = threshold_mode
self._prepare_for_warmup()
def state_dict(self):
return {key: value for key, value in self.__dict__.items() if key != 'optimizer'}
def load_state_dict(self, state_dict):
self.__dict__.update(state_dict)
self._init_is_better(mode=self.mode, threshold=self.threshold, threshold_mode=self.threshold_mode)
class CosineAnnealingLRWithWarmup(object):
"""
adjust lr:
args:
warmup_lr: float or None, the learning rate to be touched after warmup
warmup: int, the number of steps to warmup
"""
def __init__(self, optimizer, T_max, last_epoch=-1, verbose=False,
min_lr=0, warmup_lr=None, warmup=0):
self.optimizer = optimizer
self.T_max = T_max
self.last_epoch = last_epoch
self.verbose = verbose
self.warmup_lr = warmup_lr
self.warmup = warmup
if isinstance(min_lr, list) or isinstance(min_lr, tuple):
if len(min_lr) != len(optimizer.param_groups):
raise ValueError("expected {} min_lrs, got {}".format(
len(optimizer.param_groups), len(min_lr)))
self.min_lrs = list(min_lr)
else:
self.min_lrs = [min_lr] * len(optimizer.param_groups)
self.max_lrs = [lr for lr in self.min_lrs]
self._prepare_for_warmup()
def step(self):
epoch = self.last_epoch + 1
self.last_epoch = epoch
if epoch <= self.warmup:
self._increase_lr(epoch)
else:
self._reduce_lr(epoch)
def _reduce_lr(self, epoch):
for i, param_group in enumerate(self.optimizer.param_groups):
progress = float(epoch - self.warmup) / float(max(1, self.T_max - self.warmup))
factor = max(0.0, 0.5 * (1.0 + math.cos(math.pi * progress)))
old_lr = float(param_group['lr'])
new_lr = max(self.max_lrs[i] * factor, self.min_lrs[i])
param_group['lr'] = new_lr
if self.verbose:
print('Epoch {:5d}: reducing learning rate'
' of group {} to {:.4e}.'.format(epoch, i, new_lr))
def _increase_lr(self, epoch):
# used for warmup
for i, param_group in enumerate(self.optimizer.param_groups):
old_lr = float(param_group['lr'])
new_lr = old_lr + self.warmup_lr_steps[i]
param_group['lr'] = new_lr
self.max_lrs[i] = max(self.max_lrs[i], new_lr)
if self.verbose:
print('Epoch {:5d}: increasing learning rate'
' of group {} to {:.4e}.'.format(epoch, i, new_lr))
def _prepare_for_warmup(self):
if self.warmup_lr is not None:
if isinstance(self.warmup_lr, (list, tuple)):
if len(self.warmup_lr) != len(self.optimizer.param_groups):
raise ValueError("expected {} warmup_lrs, got {}".format(
len(self.optimizer.param_groups), len(self.warmup_lr)))
self.warmup_lrs = list(self.warmup_lr)
else:
self.warmup_lrs = [self.warmup_lr] * len(self.optimizer.param_groups)
else:
self.warmup_lrs = None
if self.warmup > self.last_epoch:
curr_lrs = [group['lr'] for group in self.optimizer.param_groups]
self.warmup_lr_steps = [max(0, (self.warmup_lrs[i] - curr_lrs[i])/float(self.warmup)) for i in range(len(curr_lrs))]
else:
self.warmup_lr_steps = None
def state_dict(self):
return {key: value for key, value in self.__dict__.items() if key != 'optimizer'}
def load_state_dict(self, state_dict):
self.__dict__.update(state_dict)
self._prepare_for_warmup() | 11,992 | 40.071918 | 128 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/engine/clip_grad_norm.py | from torch.nn.utils import clip_grad_norm_
class ClipGradNorm(object):
def __init__(self,
start_iteration=0,
end_iteration=-1, # if negative, the norm will be always clipped
max_norm=0.5):
self.start_iteration = start_iteration
self.end_iteration = end_iteration
self.max_norm = max_norm
self.last_epoch = -1
def __call__(self, parameters):
self.last_epoch += 1
clip = False
if self.last_epoch >= self.start_iteration:
clip = True
if self.end_iteration > 0 and self.last_epoch < self.end_iteration:
clip = True
if clip:
clip_grad_norm_(parameters, max_norm=self.max_norm)
def state_dict(self):
return {key: value for key, value in self.__dict__.items()}
def load_state_dict(self, state_dict):
self.__dict__.update(state_dict) | 935 | 29.193548 | 81 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/engine/logger.py | from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import os
import time
import sys
import torch
from image_synthesis.utils.io import write_args, save_config_to_yaml
from image_synthesis.distributed.distributed import is_primary
import torch.utils.tensorboard as tensorboard
# USE_TENSORBOARD = True
# try:
# import tensorboard
# except:
# USE_TENSORBOARD = False
class Logger(object):
def __init__(self, args):
self.args = args
self.save_dir = args.save_dir
self.is_primary = is_primary()
if self.is_primary:
os.makedirs(self.save_dir, exist_ok=True)
# save the args and config
self.config_dir = os.path.join(self.save_dir, 'configs')
os.makedirs(self.config_dir, exist_ok=True)
file_name = os.path.join(self.config_dir, 'args.txt')
write_args(args, file_name)
log_dir = os.path.join(self.save_dir, 'logs')
if not os.path.exists(log_dir):
os.makedirs(log_dir, exist_ok=True)
self.text_writer = open(os.path.join(log_dir, 'log.txt'), 'a') # 'w')
if args.tensorboard:
self.log_info('using tensorboard')
self.tb_writer = torch.utils.tensorboard.SummaryWriter(log_dir=log_dir) # tensorboard.SummaryWriter(log_dir=log_dir)
else:
self.tb_writer = None
def save_config(self, config):
if self.is_primary:
save_config_to_yaml(config, os.path.join(self.config_dir, 'config.yaml'))
def log_info(self, info, check_primary=True):
if self.is_primary or (not check_primary):
print(info)
if self.is_primary:
info = str(info)
time_str = time.strftime('%Y-%m-%d-%H-%M')
info = '{}: {}'.format(time_str, info)
if not info.endswith('\n'):
info += '\n'
self.text_writer.write(info)
self.text_writer.flush()
def add_scalar(self, **kargs):
"""Log a scalar variable."""
if self.is_primary:
if self.tb_writer is not None:
self.tb_writer.add_scalar(**kargs)
def add_scalars(self, **kargs):
"""Log a scalar variable."""
if self.is_primary:
if self.tb_writer is not None:
self.tb_writer.add_scalars(**kargs)
def add_image(self, **kargs):
"""Log a scalar variable."""
if self.is_primary:
if self.tb_writer is not None:
self.tb_writer.add_image(**kargs)
def add_images(self, **kargs):
"""Log a scalar variable."""
if self.is_primary:
if self.tb_writer is not None:
self.tb_writer.add_images(**kargs)
def close(self):
if self.is_primary:
self.text_writer.close()
self.tb_writer.close()
| 3,005 | 32.4 | 132 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/engine/solver.py | # ------------------------------------------
# VQ-Diffusion
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
# written By Shuyang Gu
# ------------------------------------------
import os
import time
import math
import torch
import threading
import multiprocessing
import copy
from PIL import Image
from torch.nn.utils import clip_grad_norm_, clip_grad_norm
import torchvision
from image_synthesis.utils.misc import instantiate_from_config, format_seconds
from image_synthesis.distributed.distributed import reduce_dict
from image_synthesis.distributed.distributed import is_primary, get_rank
from image_synthesis.utils.misc import get_model_parameters_info
from image_synthesis.engine.lr_scheduler import ReduceLROnPlateauWithWarmup, CosineAnnealingLRWithWarmup
from image_synthesis.engine.ema import EMA
from torch.optim.lr_scheduler import ReduceLROnPlateau, CosineAnnealingLR
try:
from torch.cuda.amp import autocast, GradScaler
AMP = True
except:
print('Warning: import torch.amp failed, so no amp will be used!')
AMP = False
STEP_WITH_LOSS_SCHEDULERS = (ReduceLROnPlateauWithWarmup, ReduceLROnPlateau)
class Solver(object):
def __init__(self, config, args, model, dataloader, logger):
self.config = config
self.args = args
self.model = model
self.dataloader = dataloader
self.logger = logger
self.max_epochs = config['solver']['max_epochs']
self.save_epochs = config['solver']['save_epochs']
self.save_iterations = config['solver'].get('save_iterations', -1)
self.sample_iterations = config['solver']['sample_iterations']
if self.sample_iterations == 'epoch':
self.sample_iterations = self.dataloader['train_iterations']
self.validation_epochs = config['solver'].get('validation_epochs', 2)
assert isinstance(self.save_epochs, (int, list))
assert isinstance(self.validation_epochs, (int, list))
self.debug = config['solver'].get('debug', False)
self.last_epoch = -1
self.last_iter = -1
self.ckpt_dir = os.path.join(args.save_dir, 'checkpoint')
self.image_dir = os.path.join(args.save_dir, 'images')
os.makedirs(self.ckpt_dir, exist_ok=True)
os.makedirs(self.image_dir, exist_ok=True)
# get grad_clipper
if 'clip_grad_norm' in config['solver']:
self.clip_grad_norm = instantiate_from_config(config['solver']['clip_grad_norm'])
else:
self.clip_grad_norm = None
# get lr
adjust_lr = config['solver'].get('adjust_lr', 'sqrt')
base_lr = config['solver'].get('base_lr', 1.0e-4)
if adjust_lr == 'none':
self.lr = base_lr
elif adjust_lr == 'sqrt':
self.lr = base_lr * math.sqrt(args.world_size * config['dataloader']['batch_size'])
elif adjust_lr == 'linear':
self.lr = base_lr * args.world_size * config['dataloader']['batch_size']
else:
raise NotImplementedError('Unknown type of adjust lr {}!'.format(adjust_lr))
self.logger.log_info('Get lr {} from base lr {} with {}'.format(self.lr, base_lr, adjust_lr))
if hasattr(model, 'get_optimizer_and_scheduler') and callable(getattr(model, 'get_optimizer_and_scheduler')):
optimizer_and_scheduler = model.get_optimizer_and_scheduler(config['solver']['optimizers_and_schedulers'])
else:
optimizer_and_scheduler = self._get_optimizer_and_scheduler(config['solver']['optimizers_and_schedulers'])
assert type(optimizer_and_scheduler) == type({}), 'optimizer and schduler should be a dict!'
self.optimizer_and_scheduler = optimizer_and_scheduler
# configre for ema
if 'ema' in config['solver'] and args.local_rank == 0:
ema_args = config['solver']['ema']
ema_args['model'] = self.model
self.ema = EMA(**ema_args)
else:
self.ema = None
self.logger.log_info(str(get_model_parameters_info(self.model)))
self.model.cuda()
self.device = self.model.device
if self.args.distributed:
self.logger.log_info('Distributed, begin DDP the model...')
self.model = torch.nn.parallel.DistributedDataParallel(self.model, device_ids=[self.args.gpu], find_unused_parameters=False)
self.logger.log_info('Distributed, DDP model done!')
# prepare for amp
self.args.amp = self.args.amp and AMP
if self.args.amp:
self.scaler = GradScaler()
self.logger.log_info('Using AMP for training!')
self.logger.log_info("{}: global rank {}: prepare solver done!".format(self.args.name,self.args.global_rank), check_primary=False)
def _get_optimizer_and_scheduler(self, op_sc_list):
optimizer_and_scheduler = {}
for op_sc_cfg in op_sc_list:
op_sc = {
'name': op_sc_cfg.get('name', 'none'),
'start_epoch': op_sc_cfg.get('start_epoch', 0),
'end_epoch': op_sc_cfg.get('end_epoch', -1),
'start_iteration': op_sc_cfg.get('start_iteration', 0),
'end_iteration': op_sc_cfg.get('end_iteration', -1),
}
if op_sc['name'] == 'none':
# parameters = self.model.parameters()
parameters = filter(lambda p: p.requires_grad, self.model.parameters())
else:
# NOTE: get the parameters with the given name, the parameters() should be overide
parameters = self.model.parameters(name=op_sc['name'])
# build optimizer
op_cfg = op_sc_cfg.get('optimizer', {'target': 'torch.optim.SGD', 'params': {}})
if 'params' not in op_cfg:
op_cfg['params'] = {}
if 'lr' not in op_cfg['params']:
op_cfg['params']['lr'] = self.lr
op_cfg['params']['params'] = parameters
optimizer = instantiate_from_config(op_cfg)
op_sc['optimizer'] = {
'module': optimizer,
'step_iteration': op_cfg.get('step_iteration', 1)
}
assert isinstance(op_sc['optimizer']['step_iteration'], int), 'optimizer steps should be a integer number of iterations'
# build scheduler
if 'scheduler' in op_sc_cfg:
sc_cfg = op_sc_cfg['scheduler']
sc_cfg['params']['optimizer'] = optimizer
# for cosine annealing lr, compute T_max
if sc_cfg['target'].split('.')[-1] in ['CosineAnnealingLRWithWarmup', 'CosineAnnealingLR']:
T_max = self.max_epochs * self.dataloader['train_iterations']
sc_cfg['params']['T_max'] = T_max
scheduler = instantiate_from_config(sc_cfg)
op_sc['scheduler'] = {
'module': scheduler,
'step_iteration': sc_cfg.get('step_iteration', 1)
}
if op_sc['scheduler']['step_iteration'] == 'epoch':
op_sc['scheduler']['step_iteration'] = self.dataloader['train_iterations']
optimizer_and_scheduler[op_sc['name']] = op_sc
return optimizer_and_scheduler
def _get_lr(self, return_type='str'):
lrs = {}
for op_sc_n, op_sc in self.optimizer_and_scheduler.items():
lr = op_sc['optimizer']['module'].state_dict()['param_groups'][0]['lr']
lrs[op_sc_n+'_lr'] = round(lr, 10)
if return_type == 'str':
lrs = str(lrs)
lrs = lrs.replace('none', 'lr').replace('{', '').replace('}','').replace('\'', '')
elif return_type == 'dict':
pass
else:
raise ValueError('Unknow of return type: {}'.format(return_type))
return lrs
def sample(self, batch, phase='train', step_type='iteration'):
tic = time.time()
self.logger.log_info('Begin to sample...')
if self.ema is not None:
self.ema.modify_to_inference()
suffix = '_ema'
else:
suffix = ''
if isinstance(self.model, torch.nn.parallel.DistributedDataParallel):
model = self.model.module
else:
model = self.model
with torch.no_grad():
if self.debug == False:
if self.args.amp:
with autocast():
samples = model.sample(batch=batch, step=self.last_iter)
else:
samples = model.sample(batch=batch, step=self.last_iter)
else:
samples = model.sample(batch=batch[0].cuda(), step=self.last_iter)
step = self.last_iter if step_type == 'iteration' else self.last_epoch
for k, v in samples.items():
save_dir = os.path.join(self.image_dir, phase, k)
os.makedirs(save_dir, exist_ok=True)
save_path = os.path.join(save_dir, 'e{:010d}_itr{:010d}_rank{}{}'.format(self.last_epoch, self.last_iter%self.dataloader['train_iterations'], get_rank(), suffix))
if torch.is_tensor(v) and v.dim() == 4 and v.shape[1] in [1, 3]: # image
im = v
im = im.to(torch.uint8)
self.logger.add_images(tag='{}/{}e_{}itr/{}'.format(phase, self.last_epoch, self.last_iter%self.dataloader['train_iterations'], k), img_tensor=im, global_step=step, dataformats='NCHW')
# save images
im_grid = torchvision.utils.make_grid(im)
im_grid = im_grid.permute(1, 2, 0).to('cpu').numpy()
im_grid = Image.fromarray(im_grid)
im_grid.save(save_path + '.jpg')
self.logger.log_info('save {} to {}'.format(k, save_path+'.jpg'))
else: # may be other values, such as text caption
with open(save_path+'.txt', 'a') as f:
f.write(str(v)+'\n')
f.close()
self.logger.log_info('save {} to {}'.format(k, save_path+'txt'))
if self.ema is not None:
self.ema.modify_to_train()
self.logger.log_info('Sample done, time: {:.2f}'.format(time.time() - tic))
def step(self, batch, phase='train'):
loss = {}
if self.debug == False:
for k, v in batch.items():
if torch.is_tensor(v):
batch[k] = v.cuda()
else:
batch = batch[0].cuda()
for op_sc_n, op_sc in self.optimizer_and_scheduler.items():
if phase == 'train':
# check if this optimizer and scheduler is valid in this iteration and epoch
if op_sc['start_iteration'] > self.last_iter:
continue
if op_sc['end_iteration'] > 0 and op_sc['end_iteration'] <= self.last_iter:
continue
if op_sc['start_epoch'] > self.last_epoch:
continue
if op_sc['end_epoch'] > 0 and op_sc['end_epoch'] <= self.last_epoch:
continue
input = {
'batch': batch,
'return_loss': True,
'step': self.last_iter,
}
if op_sc_n != 'none':
input['name'] = op_sc_n
if phase == 'train':
if self.args.amp:
with autocast():
output = self.model(**input)
else:
output = self.model(**input)
else:
with torch.no_grad():
if self.args.amp:
with autocast():
output = self.model(**input)
else:
output = self.model(**input)
if phase == 'train':
if op_sc['optimizer']['step_iteration'] > 0 and (self.last_iter + 1) % op_sc['optimizer']['step_iteration'] == 0:
op_sc['optimizer']['module'].zero_grad()
if self.args.amp:
self.scaler.scale(output['loss']).backward()
if self.clip_grad_norm is not None:
self.clip_grad_norm(self.model.parameters())
self.scaler.step(op_sc['optimizer']['module'])
self.scaler.update()
else:
output['loss'].backward()
if self.clip_grad_norm is not None:
self.clip_grad_norm(self.model.parameters())
op_sc['optimizer']['module'].step()
if 'scheduler' in op_sc:
if op_sc['scheduler']['step_iteration'] > 0 and (self.last_iter + 1) % op_sc['scheduler']['step_iteration'] == 0:
if isinstance(op_sc['scheduler']['module'], STEP_WITH_LOSS_SCHEDULERS):
op_sc['scheduler']['module'].step(output.get('loss'))
else:
op_sc['scheduler']['module'].step()
# update ema model
if self.ema is not None:
self.ema.update(iteration=self.last_iter)
loss[op_sc_n] = {k: v for k, v in output.items() if ('loss' in k or 'acc' in k)}
return loss
def save(self, force=False):
if is_primary():
# save with the epoch specified name
if self.save_iterations > 0:
if (self.last_iter + 1) % self.save_iterations == 0:
save = True
else:
save = False
else:
if isinstance(self.save_epochs, int):
save = (self.last_epoch + 1) % self.save_epochs == 0
else:
save = (self.last_epoch + 1) in self.save_epochs
if save or force:
state_dict = {
'last_epoch': self.last_epoch,
'last_iter': self.last_iter,
'model': self.model.module.state_dict() if isinstance(self.model, torch.nn.parallel.DistributedDataParallel) else self.model.state_dict()
}
if self.ema is not None:
state_dict['ema'] = self.ema.state_dict()
if self.clip_grad_norm is not None:
state_dict['clip_grad_norm'] = self.clip_grad_norm.state_dict()
# add optimizers and schedulers
optimizer_and_scheduler = {}
for op_sc_n, op_sc in self.optimizer_and_scheduler.items():
state_ = {}
for k in op_sc:
if k in ['optimizer', 'scheduler']:
op_or_sc = {kk: vv for kk, vv in op_sc[k].items() if kk != 'module'}
op_or_sc['module'] = op_sc[k]['module'].state_dict()
state_[k] = op_or_sc
else:
state_[k] = op_sc[k]
optimizer_and_scheduler[op_sc_n] = state_
state_dict['optimizer_and_scheduler'] = optimizer_and_scheduler
if save:
save_path = os.path.join(self.ckpt_dir, '{}e_{}iter.pth'.format(str(self.last_epoch).zfill(6), self.last_iter))
torch.save(state_dict, save_path)
self.logger.log_info('saved in {}'.format(save_path))
# save with the last name
save_path = os.path.join(self.ckpt_dir, 'last.pth')
torch.save(state_dict, save_path)
self.logger.log_info('saved in {}'.format(save_path))
def resume(self,
path=None, # The path of last.pth
load_optimizer_and_scheduler=True, # whether to load optimizers and scheduler
load_others=True # load other informations
):
if path is None:
path = os.path.join(self.ckpt_dir, 'last.pth')
if os.path.exists(path):
state_dict = torch.load(path, map_location='cuda:{}'.format(self.args.local_rank))
if load_others:
self.last_epoch = state_dict['last_epoch']
self.last_iter = state_dict['last_iter']
if isinstance(self.model, torch.nn.parallel.DistributedDataParallel):
try:
self.model.module.load_state_dict(state_dict['model'])
except:
model_dict = self.model.module.state_dict()
temp_state_dict = {k:v for k,v in state_dict['model'].items() if k in model_dict.keys()}
model_dict.update(temp_state_dict)
self.model.module.load_state_dict(model_dict)
else:
self.model.load_state_dict(state_dict['model'])
if 'ema' in state_dict and self.ema is not None:
try:
self.ema.load_state_dict(state_dict['ema'])
except:
model_dict = self.ema.state_dict()
temp_state_dict = {k:v for k,v in state_dict['ema'].items() if k in model_dict.keys()}
model_dict.update(temp_state_dict)
self.ema.load_state_dict(model_dict)
if 'clip_grad_norm' in state_dict and self.clip_grad_norm is not None:
self.clip_grad_norm.load_state_dict(state_dict['clip_grad_norm'])
# handle optimizer and scheduler
for op_sc_n, op_sc in state_dict['optimizer_and_scheduler'].items():
for k in op_sc:
if k in ['optimizer', 'scheduler']:
for kk in op_sc[k]:
if kk == 'module' and load_optimizer_and_scheduler:
self.optimizer_and_scheduler[op_sc_n][k][kk].load_state_dict(op_sc[k][kk])
elif load_others: # such as step_iteration, ...
self.optimizer_and_scheduler[op_sc_n][k][kk] = op_sc[k][kk]
elif load_others: # such as start_epoch, end_epoch, ....
self.optimizer_and_scheduler[op_sc_n][k] = op_sc[k]
self.logger.log_info('Resume from {}'.format(path))
def train_epoch(self):
self.model.train()
self.last_epoch += 1
if self.args.distributed:
self.dataloader['train_loader'].sampler.set_epoch(self.last_epoch)
epoch_start = time.time()
itr_start = time.time()
itr = -1
for itr, batch in enumerate(self.dataloader['train_loader']):
if itr == 0:
print("time2 is " + str(time.time()))
data_time = time.time() - itr_start
step_start = time.time()
self.last_iter += 1
loss = self.step(batch, phase='train')
# logging info
if self.logger is not None and self.last_iter % self.args.log_frequency == 0:
info = '{}: train'.format(self.args.name)
info = info + ': Epoch {}/{} iter {}/{}'.format(self.last_epoch, self.max_epochs, self.last_iter%self.dataloader['train_iterations'], self.dataloader['train_iterations'])
for loss_n, loss_dict in loss.items():
info += ' ||'
loss_dict = reduce_dict(loss_dict)
info += '' if loss_n == 'none' else ' {}'.format(loss_n)
# info = info + ': Epoch {}/{} iter {}/{}'.format(self.last_epoch, self.max_epochs, self.last_iter%self.dataloader['train_iterations'], self.dataloader['train_iterations'])
for k in loss_dict:
info += ' | {}: {:.4f}'.format(k, float(loss_dict[k]))
self.logger.add_scalar(tag='train/{}/{}'.format(loss_n, k), scalar_value=float(loss_dict[k]), global_step=self.last_iter)
# log lr
lrs = self._get_lr(return_type='dict')
for k in lrs.keys():
lr = lrs[k]
self.logger.add_scalar(tag='train/{}_lr'.format(k), scalar_value=lrs[k], global_step=self.last_iter)
# add lr to info
info += ' || {}'.format(self._get_lr())
# add time consumption to info
spend_time = time.time() - self.start_train_time
itr_time_avg = spend_time / (self.last_iter + 1)
info += ' || data_time: {dt}s | fbward_time: {fbt}s | iter_time: {it}s | iter_avg_time: {ita}s | epoch_time: {et} | spend_time: {st} | left_time: {lt}'.format(
dt=round(data_time, 1),
it=round(time.time() - itr_start, 1),
fbt=round(time.time() - step_start, 1),
ita=round(itr_time_avg, 1),
et=format_seconds(time.time() - epoch_start),
st=format_seconds(spend_time),
lt=format_seconds(itr_time_avg*self.max_epochs*self.dataloader['train_iterations']-spend_time)
)
self.logger.log_info(info)
itr_start = time.time()
# sample
if self.sample_iterations > 0 and (self.last_iter + 1) % self.sample_iterations == 0:
# print("save model here")
# self.save(force=True)
# print("save model done")
self.model.eval()
self.sample(batch, phase='train', step_type='iteration')
self.model.train()
# modify here to make sure dataloader['train_iterations'] is correct
assert itr >= 0, "The data is too less to form one iteration!"
self.dataloader['train_iterations'] = itr + 1
def validate_epoch(self):
if 'validation_loader' not in self.dataloader:
val = False
else:
if isinstance(self.validation_epochs, int):
val = (self.last_epoch + 1) % self.validation_epochs == 0
else:
val = (self.last_epoch + 1) in self.validation_epochs
if val:
if self.args.distributed:
self.dataloader['validation_loader'].sampler.set_epoch(self.last_epoch)
self.model.eval()
overall_loss = None
epoch_start = time.time()
itr_start = time.time()
itr = -1
for itr, batch in enumerate(self.dataloader['validation_loader']):
data_time = time.time() - itr_start
step_start = time.time()
loss = self.step(batch, phase='val')
for loss_n, loss_dict in loss.items():
loss[loss_n] = reduce_dict(loss_dict)
if overall_loss is None:
overall_loss = loss
else:
for loss_n, loss_dict in loss.items():
for k, v in loss_dict.items():
overall_loss[loss_n][k] = (overall_loss[loss_n][k] * itr + loss[loss_n][k]) / (itr + 1)
if self.logger is not None and (itr+1) % self.args.log_frequency == 0:
info = '{}: val'.format(self.args.name)
info = info + ': Epoch {}/{} | iter {}/{}'.format(self.last_epoch, self.max_epochs, itr, self.dataloader['validation_iterations'])
for loss_n, loss_dict in loss.items():
info += ' ||'
info += '' if loss_n == 'none' else ' {}'.format(loss_n)
# info = info + ': Epoch {}/{} | iter {}/{}'.format(self.last_epoch, self.max_epochs, itr, self.dataloader['validation_iterations'])
for k in loss_dict:
info += ' | {}: {:.4f}'.format(k, float(loss_dict[k]))
itr_time_avg = (time.time() - epoch_start) / (itr + 1)
info += ' || data_time: {dt}s | fbward_time: {fbt}s | iter_time: {it}s | epoch_time: {et} | left_time: {lt}'.format(
dt=round(data_time, 1),
fbt=round(time.time() - step_start, 1),
it=round(time.time() - itr_start, 1),
et=format_seconds(time.time() - epoch_start),
lt=format_seconds(itr_time_avg*(self.dataloader['train_iterations']-itr-1))
)
self.logger.log_info(info)
itr_start = time.time()
# modify here to make sure dataloader['validation_iterations'] is correct
assert itr >= 0, "The data is too less to form one iteration!"
self.dataloader['validation_iterations'] = itr + 1
if self.logger is not None:
info = '{}: val'.format(self.args.name)
for loss_n, loss_dict in overall_loss.items():
info += '' if loss_n == 'none' else ' {}'.format(loss_n)
info += ': Epoch {}/{}'.format(self.last_epoch, self.max_epochs)
for k in loss_dict:
info += ' | {}: {:.4f}'.format(k, float(loss_dict[k]))
self.logger.add_scalar(tag='val/{}/{}'.format(loss_n, k), scalar_value=float(loss_dict[k]), global_step=self.last_epoch)
self.logger.log_info(info)
def validate(self):
self.validation_epoch()
def train(self):
start_epoch = self.last_epoch + 1
self.start_train_time = time.time()
self.logger.log_info('{}: global rank {}: start training...'.format(self.args.name, self.args.global_rank), check_primary=False)
for epoch in range(start_epoch, self.max_epochs):
self.train_epoch()
self.save(force=True)
self.validate_epoch()
| 26,443 | 47.08 | 204 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/engine/ema.py | import torch
import copy
class EMA(object):
def __init__(self,
model,
decay=0.99,
update_interval=1,
device=torch.device('cpu')):
self.decay = decay
self.update_iterval = update_interval
self.device = device
self.model = model
with torch.no_grad():
if hasattr(model, 'get_ema_model') and callable(model.get_ema_model):
self.ema_model = copy.deepcopy(model.get_ema_model())
self.cur_state_dict = model.get_ema_model().state_dict()
else:
self.ema_model = copy.deepcopy(model)
self.cur_state_dict = model.state_dict()
self.ema_model.to(self.device)
self.cur_state_dict = {k: v.clone().to(self.device) for k, v in self.cur_state_dict.items()}
def update(self, iteration):
if (iteration + 1) % self.update_iterval == 0:
# print('{} Update ema'.format(iteration))
if hasattr(self.model, 'get_ema_model') and callable(self.model.get_ema_model):
cur_state_dict = self.model.get_ema_model().state_dict()
else:
cur_state_dict = self.model.state_dict()
ema_state_dict = self.ema_model.state_dict()
for k in ema_state_dict.keys():
ema_state_dict[k] = ema_state_dict[k] * self.decay + cur_state_dict[k].clone().to(self.device) * (1-self.decay)
self.ema_model.load_state_dict(ema_state_dict)
def state_dict(self):
return self.ema_model.state_dict()
def load_state_dict(self, state_dict, strict=True):
state_dict_ = {k: v.clone().to(self.device) for k, v in state_dict.items()}
self.ema_model.load_state_dict(state_dict_, strict=strict)
def modify_to_inference(self):
# get current model
if hasattr(self.model, 'get_ema_model') and callable(self.model.get_ema_model):
self.cur_state_dict = self.model.get_ema_model().state_dict()
else:
self.cur_state_dict = self.model.state_dict()
self.cur_state_dict = {k: v.clone().to(self.device) for k, v in self.cur_state_dict.items()}
ema_state_dict = self.ema_model.state_dict()
ema_state_dict = {k: v.to(self.model.device) for k, v in ema_state_dict.items()}
if hasattr(self.model, 'get_ema_model') and callable(self.model.get_ema_model):
self.model.get_ema_model().load_state_dict(ema_state_dict)
else:
self.model.load_state_dict(ema_state_dict)
def modify_to_train(self):
self.cur_state_dict = {k: v.clone().to(self.model.device) for k, v in self.cur_state_dict.items()}
if hasattr(self.model, 'get_ema_model') and callable(self.model.get_ema_model):
self.model.get_ema_model().load_state_dict(self.cur_state_dict)
else:
self.model.load_state_dict(self.cur_state_dict)
| 2,968 | 42.028986 | 127 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/utils/misc.py | import importlib
import random
import numpy as np
import torch
import warnings
import os
def seed_everything(seed, cudnn_deterministic=False):
"""
Function that sets seed for pseudo-random number generators in:
pytorch, numpy, python.random
Args:
seed: the integer value seed for global random state
"""
if seed is not None:
print(f"Global seed set to {seed}")
random.seed(seed)
np.random.seed(seed)
torch.manual_seed(seed)
torch.cuda.manual_seed_all(seed)
if cudnn_deterministic:
torch.backends.cudnn.deterministic = True
warnings.warn('You have chosen to seed training. '
'This will turn on the CUDNN deterministic setting, '
'which can slow down your training considerably! '
'You may see unexpected behavior when restarting '
'from checkpoints.')
def merge_opts_to_config(config, opts):
def modify_dict(c, nl, v):
if len(nl) == 1:
c[nl[0]] = type(c[nl[0]])(v)
else:
# print(nl)
c[nl[0]] = modify_dict(c[nl[0]], nl[1:], v)
return c
if opts is not None and len(opts) > 0:
assert len(opts) % 2 == 0, "each opts should be given by the name and values! The length shall be even number!"
for i in range(len(opts) // 2):
name = opts[2*i]
value = opts[2*i+1]
config = modify_dict(config, name.split('.'), value)
return config
def modify_config_for_debug(config):
config['dataloader']['num_workers'] = 0
config['dataloader']['batch_size'] = 1
return config
def get_model_parameters_info(model):
# for mn, m in model.named_modules():
parameters = {'overall': {'trainable': 0, 'non_trainable': 0, 'total': 0}}
for child_name, child_module in model.named_children():
parameters[child_name] = {'trainable': 0, 'non_trainable': 0}
for pn, p in child_module.named_parameters():
if p.requires_grad:
parameters[child_name]['trainable'] += p.numel()
else:
parameters[child_name]['non_trainable'] += p.numel()
parameters[child_name]['total'] = parameters[child_name]['trainable'] + parameters[child_name]['non_trainable']
parameters['overall']['trainable'] += parameters[child_name]['trainable']
parameters['overall']['non_trainable'] += parameters[child_name]['non_trainable']
parameters['overall']['total'] += parameters[child_name]['total']
# format the numbers
def format_number(num):
K = 2**10
M = 2**20
G = 2**30
if num > G: # K
uint = 'G'
num = round(float(num)/G, 2)
elif num > M:
uint = 'M'
num = round(float(num)/M, 2)
elif num > K:
uint = 'K'
num = round(float(num)/K, 2)
else:
uint = ''
return '{}{}'.format(num, uint)
def format_dict(d):
for k, v in d.items():
if isinstance(v, dict):
format_dict(v)
else:
d[k] = format_number(v)
format_dict(parameters)
return parameters
def format_seconds(seconds):
h = int(seconds // 3600)
m = int(seconds // 60 - h * 60)
s = int(seconds % 60)
d = int(h // 24)
h = h - d * 24
if d == 0:
if h == 0:
if m == 0:
ft = '{:02d}s'.format(s)
else:
ft = '{:02d}m:{:02d}s'.format(m, s)
else:
ft = '{:02d}h:{:02d}m:{:02d}s'.format(h, m, s)
else:
ft = '{:d}d:{:02d}h:{:02d}m:{:02d}s'.format(d, h, m, s)
return ft
def instantiate_from_config(config):
if config is None:
return None
if not "target" in config:
raise KeyError("Expected key `target` to instantiate.")
module, cls = config["target"].rsplit(".", 1)
cls = getattr(importlib.import_module(module, package=None), cls)
return cls(**config.get("params", dict()))
def class_from_string(class_name):
module, cls = class_name.rsplit(".", 1)
cls = getattr(importlib.import_module(module, package=None), cls)
return cls
def get_all_file(dir, end_with='.h5'):
if isinstance(end_with, str):
end_with = [end_with]
filenames = []
for root, dirs, files in os.walk(dir):
for f in files:
for ew in end_with:
if f.endswith(ew):
filenames.append(os.path.join(root, f))
break
return filenames
def get_sub_dirs(dir, abs=True):
sub_dirs = os.listdir(dir)
if abs:
sub_dirs = [os.path.join(dir, s) for s in sub_dirs]
return sub_dirs
def get_model_buffer(model):
state_dict = model.state_dict()
buffers_ = {}
params_ = {n: p for n, p in model.named_parameters()}
for k in state_dict:
if k not in params_:
buffers_[k] = state_dict[k]
return buffers_
| 5,066 | 29.160714 | 119 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/utils/io.py | import sys
import yaml
import torch
import json
def load_yaml_config(path):
with open(path) as f:
config = yaml.full_load(f)
return config
def save_config_to_yaml(config, path):
assert path.endswith('.yaml')
with open(path, 'w') as f:
f.write(yaml.dump(config))
f.close()
def save_dict_to_json(d, path, indent=None):
json.dump(d, open(path, 'w'), indent=indent)
def load_dict_from_json(path):
return json.load(open(path, 'r'))
def write_args(args, path):
args_dict = dict((name, getattr(args, name)) for name in dir(args)if not name.startswith('_'))
with open(path, 'a') as args_file:
args_file.write('==> torch version: {}\n'.format(torch.__version__))
args_file.write('==> cudnn version: {}\n'.format(torch.backends.cudnn.version()))
args_file.write('==> Cmd:\n')
args_file.write(str(sys.argv))
args_file.write('\n==> args:\n')
for k, v in sorted(args_dict.items()):
args_file.write(' %s: %s\n' % (str(k), str(v)))
args_file.close() | 1,067 | 28.666667 | 98 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/data/cub200_dataset.py | from torch.utils.data import Dataset
import numpy as np
import io
from PIL import Image
import os
import json
import random
from image_synthesis.utils.misc import instantiate_from_config
from tqdm import tqdm
import pickle
def load_img(filepath):
img = Image.open(filepath).convert('RGB')
return img
class Cub200Dataset(Dataset):
def __init__(self, data_root, phase = 'train', im_preprocessor_config=None, drop_caption_rate=0.0):
self.transform = instantiate_from_config(im_preprocessor_config)
self.image_folder = os.path.join(data_root, 'images')
self.root = os.path.join(data_root, phase)
pickle_path = os.path.join(self.root, "filenames.pickle")
self.name_list = pickle.load(open(pickle_path, 'rb'), encoding="bytes")
self.num = len(self.name_list)
# load all caption file to dict in memory
self.caption_dict = {}
for index in tqdm(range(self.num)):
name = self.name_list[index]
this_text_path = os.path.join(data_root, 'text', 'text', name+'.txt')
with open(this_text_path, 'r') as f:
caption = f.readlines()
self.caption_dict[name] = caption
print("load caption file done")
self.drop_rate = drop_caption_rate
self.phase = phase
def __len__(self):
return self.num
def __getitem__(self, index):
name = self.name_list[index]
image_path = os.path.join(self.image_folder, name+'.jpg')
image = load_img(image_path)
image = np.array(image).astype(np.uint8)
image = self.transform(image = image)['image']
caption_list = self.caption_dict[name]
caption = random.choice(caption_list).replace('\n', '').lower()
data = {
'image': np.transpose(image.astype(np.float32), (2, 0, 1)),
'text': caption if (self.phase != 'train' or self.drop_rate < 1e-6 or random.random() >= self.drop_rate) else '',
}
return data
| 2,040 | 33.016667 | 129 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/data/mscoco_dataset.py | from torch.utils.data import Dataset
import numpy as np
import io
from PIL import Image
import os
import json
import random
from image_synthesis.utils.misc import instantiate_from_config
def load_img(filepath):
img = Image.open(filepath).convert('RGB')
return img
class CocoDataset(Dataset):
def __init__(self, data_root, phase = 'train', im_preprocessor_config=None, drop_caption_rate=0.0):
self.transform = instantiate_from_config(im_preprocessor_config)
self.root = os.path.join(data_root, phase)
# input_file = os.path.join(data_root, input_file)
caption_file = "captions_"+phase+"2014.json"
caption_file = os.path.join(data_root, "annotations", caption_file)
self.json_file = json.load(open(caption_file, 'r'))
print("length of the dataset is ")
print(len(self.json_file['annotations']))
self.num = len(self.json_file['annotations'])
self.image_prename = "COCO_" + phase + "2014_"
self.folder_path = os.path.join(data_root, phase+'2014', phase+'2014')
self.drop_rate = drop_caption_rate
self.phase = phase
def __len__(self):
return self.num
def __getitem__(self, index):
this_item = self.json_file['annotations'][index]
caption = this_item['caption'].lower()
image_name = str(this_item['image_id']).zfill(12)
image_path = os.path.join(self.folder_path, self.image_prename+image_name+'.jpg')
image = load_img(image_path)
image = np.array(image).astype(np.uint8)
image = self.transform(image = image)['image']
data = {
'image': np.transpose(image.astype(np.float32), (2, 0, 1)),
'text': caption if (self.phase != 'train' or self.drop_rate < 1e-6 or random.random() >= self.drop_rate) else '',
}
return data
| 1,873 | 36.48 | 129 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/data/imagenet_dataset.py | from torch.utils.data import Dataset
import numpy as np
import io
from PIL import Image
import os
import json
import random
from image_synthesis.utils.misc import instantiate_from_config
def load_img(filepath):
img = Image.open(filepath).convert('RGB')
return img
class ImageNetDataset(Dataset):
def __init__(self, data_root, input_file, phase = 'train', im_preprocessor_config=None, drop_caption_rate=0.0):
self.transform = instantiate_from_config(im_preprocessor_config)
self.root = os.path.join(data_root, phase)
input_file = os.path.join(data_root, input_file)
temp_label = json.load(open('image_synthesis/data/imagenet_class_index.json', 'r'))
self.labels = {}
for i in range(1000):
self.labels[temp_label[str(i)][0]] = i
self.A_paths = []
self.A_labels = []
with open(input_file, 'r') as f:
temp_path = f.readlines()
for path in temp_path:
label = self.labels[path.split('/')[0]]
self.A_paths.append(os.path.join(self.root, path.strip()))
self.A_labels.append(label)
self.num = len(self.A_paths)
self.A_size = len(self.A_paths)
self.drop_rate = drop_caption_rate
self.phase = phase
def __len__(self):
return self.num
def __getitem__(self, index):
try:
return self.load_img(index)
except:
return self.__getitem__(random.randint(0, self.__len__()-1))
def load_img(self, index):
A_path = self.A_paths[index % self.A_size]
A = load_img(A_path)
# if self.transform is not None:
A = self.transform(A)['image']
A_label = self.A_labels[index % self.A_size]
data = {
'image': np.transpose(A.astype(np.float32), (2, 0, 1)),
'label': A_label if (self.phase != 'train' or self.drop_rate < 1e-6 or random.random() >= self.drop_rate) else 1000,
}
return data
| 2,016 | 33.775862 | 132 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/data/ffhq_dataset.py | from torch.utils.data import Dataset
import numpy as np
import io
from PIL import Image
import os
import json
import random
from image_synthesis.utils.misc import instantiate_from_config
import torchvision.datasets as datasets
class FFHQDataset(datasets.ImageFolder):
def __init__(self, data_root, im_preprocessor_config):
self.img_preprocessor = instantiate_from_config(im_preprocessor_config)
super(FFHQDataset, self).__init__(root=data_root)
def __getitem__(self, index):
# image_name = self.imgs[index][0].split('/')[-1]
image = super(FFHQDataset, self).__getitem__(index)[0]
image = self.img_preprocessor(image=np.array(image).astype(np.uint8))['image']
data = {
'image': np.transpose(image.astype(np.float32), (2, 0, 1)),
}
return data
| 848 | 31.653846 | 86 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/data/build.py | import torch
# from image_synthesis.data.base_dataset import ConcatDatasetWithIndex as ConcatDataset
from torch.utils.data import ConcatDataset
from image_synthesis.utils.misc import instantiate_from_config
from image_synthesis.distributed.distributed import is_distributed
def build_dataloader(config, args=None, return_dataset=False):
dataset_cfg = config['dataloader']
train_dataset = []
for ds_cfg in dataset_cfg['train_datasets']:
ds_cfg['params']['data_root'] = dataset_cfg.get('data_root', '')
ds = instantiate_from_config(ds_cfg)
train_dataset.append(ds)
if len(train_dataset) > 1:
train_dataset = ConcatDataset(train_dataset)
else:
train_dataset = train_dataset[0]
val_dataset = []
for ds_cfg in dataset_cfg['validation_datasets']:
ds_cfg['params']['data_root'] = dataset_cfg.get('data_root', '')
ds = instantiate_from_config(ds_cfg)
val_dataset.append(ds)
if len(val_dataset) > 1:
val_dataset = ConcatDataset(val_dataset)
else:
val_dataset = val_dataset[0]
if args is not None and args.distributed:
train_sampler = torch.utils.data.distributed.DistributedSampler(train_dataset, shuffle=True)
val_sampler = torch.utils.data.distributed.DistributedSampler(val_dataset, shuffle=False)
train_iters = len(train_sampler) // dataset_cfg['batch_size']
val_iters = len(val_sampler) // dataset_cfg['batch_size']
else:
train_sampler = None
val_sampler = None
train_iters = len(train_dataset) // dataset_cfg['batch_size']
val_iters = len(val_dataset) // dataset_cfg['batch_size']
# if args is not None and not args.debug:
# num_workers = max(2*dataset_cfg['batch_size'], dataset_cfg['num_workers'])
# num_workers = min(64, num_workers)
# else:
# num_workers = dataset_cfg['num_workers']
num_workers = dataset_cfg['num_workers']
train_loader = torch.utils.data.DataLoader(train_dataset,
batch_size=dataset_cfg['batch_size'],
shuffle=(train_sampler is None),
num_workers=num_workers,
pin_memory=True,
sampler=train_sampler,
drop_last=True,
persistent_workers=True)
val_loader = torch.utils.data.DataLoader(val_dataset,
batch_size=dataset_cfg['batch_size'],
shuffle=False, #(val_sampler is None),
num_workers=num_workers,
pin_memory=True,
sampler=val_sampler,
drop_last=True,
persistent_workers=True)
dataload_info = {
'train_loader': train_loader,
'validation_loader': val_loader,
'train_iterations': train_iters,
'validation_iterations': val_iters
}
if return_dataset:
dataload_info['train_dataset'] = train_dataset
dataload_info['validation_dataset'] = val_dataset
return dataload_info
| 3,454 | 44.460526 | 100 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/data/utils/image_preprocessor.py | import albumentations
import random
import numpy as np
from PIL import Image
import cv2
from io import BytesIO
from torchvision import transforms as trans
class DalleTransformerPreprocessor(object):
def __init__(self,
size=256,
phase='train',
additional_targets=None):
self.size = size
self.phase = phase
# ddc: following dalle to use randomcrop
self.train_preprocessor = albumentations.Compose([albumentations.RandomCrop(height=size, width=size)],
additional_targets=additional_targets)
self.val_preprocessor = albumentations.Compose([albumentations.CenterCrop(height=size, width=size)],
additional_targets=additional_targets)
def __call__(self, image, **kargs):
"""
image: PIL.Image
"""
if isinstance(image, np.ndarray):
image = Image.fromarray(image.astype(np.uint8))
w, h = image.size
s_min = min(h, w)
if self.phase == 'train':
off_h = int(random.uniform(3*(h-s_min)//8, max(3*(h-s_min)//8+1, 5*(h-s_min)//8)))
off_w = int(random.uniform(3*(w-s_min)//8, max(3*(w-s_min)//8+1, 5*(w-s_min)//8)))
# import pdb; pdb.set_trace()
image = image.crop((off_w, off_h, off_w + s_min, off_h + s_min))
# resize image
t_max = min(s_min, round(9/8*self.size))
t_max = max(t_max, self.size)
t = int(random.uniform(self.size, t_max+1))
image = image.resize((t, t))
image = np.array(image).astype(np.uint8)
image = self.train_preprocessor(image=image) #randomcrop (size,size)
else:
if w < h:
w_ = self.size
h_ = int(h * w_/w)
else:
h_ = self.size
w_ = int(w * h_/h)
image = image.resize((w_, h_))
image = np.array(image).astype(np.uint8)
image = self.val_preprocessor(image=image)
return image
class ImageNetTransformerPreprocessor(object):
def __init__(self,
size=256,
phase='train',
additional_targets=None):
self.size = size
self.phase = phase
# ddc: following dalle to use randomcrop
self.train_preprocessor = albumentations.Compose([albumentations.RandomCrop(height=size, width=size)],
additional_targets=additional_targets)
self.val_preprocessor = albumentations.Compose([albumentations.CenterCrop(height=size, width=size)],
additional_targets=additional_targets)
def __call__(self, image, **kargs):
"""
image: PIL.Image
"""
if isinstance(image, np.ndarray):
image = Image.fromarray(image.astype(np.uint8))
w, h = image.size
s_min = min(h, w)
if self.phase == 'train':
if w < h:
w_ = self.size
h_ = int(h * w_/w)
else:
h_ = self.size
w_ = int(w * h_/h)
image = image.resize((w_, h_))
image = np.array(image).astype(np.uint8)
image = self.train_preprocessor(image=image)
else:
if w < h:
w_ = self.size
h_ = int(h * w_/w)
else:
h_ = self.size
w_ = int(w * h_/h)
image = image.resize((w_, h_))
image = np.array(image).astype(np.uint8)
image = self.val_preprocessor(image=image)
return image
| 3,890 | 35.364486 | 140 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/data/utils/comm.py | """
This file contains primitives for multi-gpu communication.
This is useful when doing distributed training.
"""
import pickle
import torch
import torch.distributed as dist
# from diffdist.functional import all_gather as better_all_gather
class Comm(object):
def __init__(self, local_rank=0):
self.local_rank = 0
@property
def world_size(self):
if not dist.is_available():
return 1
if not dist.is_initialized():
return 1
return dist.get_world_size()
@property
def rank(self):
if not dist.is_available():
return 0
if not dist.is_initialized():
return 0
return dist.get_rank()
@property
def local_rank(self):
if not dist.is_available():
print("****************** yes1")
return 0
if not dist.is_initialized():
print("****************** yes2")
return 0
print("****************** yes3", self._local_rank)
return self._local_rank
@local_rank.setter
def local_rank(self, value):
if not dist.is_available():
self._local_rank = 0
if not dist.is_initialized():
self._local_rank = 0
self._local_rank = value
@property
def head(self):
return 'Rank[{}/{}]'.format(self.rank, self.world_size)
def is_main_process(self):
return self.rank == 0
def synchronize(self):
"""
Helper function to synchronize (barrier) among all processes when
using distributed training
"""
if self.world_size == 1:
return
dist.barrier()
comm = Comm()
def all_gather(data):
"""
Run all_gather on arbitrary picklable data (not necessarily tensors)
Args:
data: any picklable object
Returns:
list[data]: list of data gathered from each rank
"""
world_size = comm.world_size
if world_size == 1:
return [data]
# serialized to a Tensor
buffer = pickle.dumps(data)
storage = torch.ByteStorage.from_buffer(buffer)
tensor = torch.ByteTensor(storage).to("cuda")
# obtain Tensor size of each rank
local_size = torch.LongTensor([tensor.numel()]).to("cuda")
size_list = [torch.LongTensor([0]).to("cuda") for _ in range(world_size)]
dist.all_gather(size_list, local_size)
size_list = [int(size.item()) for size in size_list]
max_size = max(size_list)
# receiving Tensor from all ranks
# we pad the tensor because torch all_gather does not support
# gathering tensors of different shapes
tensor_list = []
for _ in size_list:
tensor_list.append(torch.ByteTensor(size=(max_size,)).to("cuda"))
if local_size != max_size:
padding = torch.ByteTensor(size=(max_size - local_size,)).to("cuda")
tensor = torch.cat((tensor, padding), dim=0)
dist.all_gather(tensor_list, tensor)
data_list = []
for size, tensor in zip(size_list, tensor_list):
buffer = tensor.cpu().numpy().tobytes()[:size]
data_list.append(pickle.loads(buffer))
return data_list
def reduce_dict(input_dict, average=True):
"""
Args:
input_dict (dict): all the values will be reduced
average (bool): whether to do average or sum
Reduce the values in the dictionary from all processes so that process with rank
0 has the averaged results. Returns a dict with the same fields as
input_dict, after reduction.
"""
world_size = comm.world_size
if world_size < 2:
return input_dict
with torch.no_grad():
names = []
values = []
# sort the keys so that they are consistent across processes
for k in sorted(input_dict.keys()):
names.append(k)
values.append(input_dict[k])
values = torch.stack(values, dim=0)
dist.reduce(values, dst=0)
if dist.get_rank() == 0 and average:
# only main process gets accumulated, so only divide by
# world_size in this case
values /= world_size
reduced_dict = {k: v for k, v in zip(names, values)}
return reduced_dict
def gather_tensors(tensor):
"""
Performs all_gather operation on the provided tensors.
*** Warning ***: torch.distributed.all_gather has no gradient.
"""
tensors_gather = [
torch.ones_like(tensor)
for _ in range(comm.world_size)
]
dist.all_gather(tensors_gather, tensor, async_op=False)
# need to do this to restore propagation of the gradients
tensors_gather[comm.rank] = tensor
output = torch.cat(tensors_gather, dim=0)
return output
def gather_tensors_fake(tensor):
"""
Performs all_gather operation on the provided tensors.
*** Warning ***: torch.distributed.all_gather has no gradient.
"""
tensors_gather = [
torch.ones_like(tensor)
for _ in range(comm.world_size)
]
dist.all_gather(tensors_gather, tensor, async_op=False)
# need to do this to restore propagation of the gradients
tensors_gather[comm.rank] = tensor
output = torch.cat(tensors_gather, dim=0)
output = torch.cat([output,output.detach()],0)
return output
def gather_nearby_tensors(tensor):
"""
Performs all_gather operation on the provided tensors.
*** Warning ***: torch.distributed.all_gather has no gradient.
"""
step=comm.rank//2
if comm.rank%2==0:
nearby_rank=step*2+1
else:
nearby_rank=step*2
cpu_tensor=tensor
tensors_gather = [
torch.ones_like(cpu_tensor)
for _ in range(comm.world_size)
]
dist.all_gather(tensors_gather, cpu_tensor, async_op=False)
# need to do this to restore propagation of the gradients
tensors_gather=[tensors_gather[nearby_rank].to(tensor.device),tensor]
output = torch.cat(tensors_gather, dim=0)
return output
def gather_tensors_with_gradient(x):
""" collect all tensor from all GPUs
args:
x: shape (mini_batch, ...)
returns:
shape (mini_batch * num_gpu, ...)
"""
x = x.contiguous()
out_list = [torch.zeros_like(x, device=x.device, dtype=x.dtype) for _ in range(comm.world_size)]
out_list = better_all_gather(out_list, x)
return torch.cat(out_list, dim=0)
gather_funcs={
"ALL":gather_tensors,
"NEAR":gather_nearby_tensors,
"GRAD":gather_tensors_with_gradient,
"FAKE":gather_tensors_fake
}
from contextlib import contextmanager
@contextmanager
def torch_distributed_zero_first():
"""
Decorator to make all processes in distributed training wait for each local_master to do something.
"""
local_rank=comm.local_rank
if local_rank not in [-1, 0]:
dist.barrier(device_ids=[local_rank])
yield
if local_rank == 0:
dist.barrier(device_ids=[0])
| 6,860 | 28.701299 | 103 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/data/utils/manage.py | from sys import stdout
import zipfile
import os.path as osp
import lmdb
import logging
from PIL import Image
import pickle
import io
import glob
import os
from pathlib import Path
import time
from threading import Thread
from queue import Queue,Empty
import subprocess
def func_wrapper(func):
def sub_func(queue,kwargs):
while True:
try:
key=queue.get(False)
ret=func(key,**kwargs)
except Empty:
break
return sub_func
class ThreadPool:
def __init__(self,n):
self.threads=[]
self.n=n
def run(self,func,array,**kwargs):
queue=Queue()
for val in array:
queue.put(val)
threads=[]
target=func_wrapper(func)
# hold_thread=subprocess.Popen("exec "+"python /mnt/blob/datasets/holder.py",shell=True,stdout=subprocess.DEVNULL)
time.sleep(1)
print(f"start loading queue {queue.qsize()}")
logging.info(f"start loading queue {queue.qsize()}")
for i in range(self.n):
print(i)
thread=Thread(target=target, args=(queue,kwargs))
thread.start()
threads.append(thread)
for thread in threads:
thread.join()
# hold_thread.kill()
home = str(Path.home())
abs_blob_path=os.path.realpath("/mnt/blob/")
CACHE_FOLDER=os.path.join(home,"caching")
USE_CACHE=True
def norm(path):
assert "*" not in path
return os.path.realpath(os.path.abspath(path))
def in_blob(file):
if abs_blob_path in file:
return True
else:
return False
def map_name(file):
path=norm(file)
path=path.lstrip(abs_blob_path+"/")
path=path.replace("/","_")
assert len(path)<250
return path
def preload(db,sync=True,load=True):
if not load:
return
print(f"loading {db.db_path}")
logging.info(f"loading {db.db_path}")
if sync:
db.initialize()
else:
p = Thread(target=db.initialize)
p.start()
def get_keys_from_lmdb(db):
with db.begin(write=False) as txn:
return list(txn.cursor().iternext(values=False))
def decode_img(byteflow):
img=Image.open(io.BytesIO(byteflow)).convert("RGB")
img.load()
return img
def decode_text(byteflow):
return pickle.loads(byteflow)
decode_funcs={
"image": decode_img,
"text": decode_text
}
class MultipleZipManager:
def __init__(self, files: list):
raise
def remove_prefix(text, prefix):
return text[len(prefix):] if text.startswith(prefix) else text
class ZipManager:
def __init__(self, db_path,data_type,prefix=None,load=True) -> None:
self.decode_func=decode_funcs[data_type]
self.db_path=db_path
cache_file=os.path.join(CACHE_FOLDER,map_name(db_path))
if USE_CACHE and os.path.exists(cache_file):
logging.info(f"using local cache {cache_file}")
self.db_path=cache_file
if prefix is None:
self.prefix = None
else:
self.prefix=f"{prefix}_"
self._init=False
preload(self,load=load)
def deinitialze(self):
self.zip_fd.close()
del self.zip_fd
self._init = False
def initialize(self,close=True):
self.zip_fd = zipfile.ZipFile(self.db_path, mode="r")
if not hasattr(self,"_keys"):
self._keys = self.zip_fd.namelist()
if self.prefix is not None:
self._keys=[self.prefix+key for key in self._keys]
self._init = True
if close:
self.deinitialze()
@property
def keys(self):
while not hasattr(self,"_keys"):
time.sleep(0.1)
return self._keys
def get(self, name):
if not self._init:
self.initialize(close=False) # https://discuss.pytorch.org/t/dataloader-stucks/14087/3
byteflow = self.zip_fd.read(name)
return self.decode_func(byteflow)
class DBManager:
def __init__(self, db_path,data_type,prefix=None,load=True) -> None:
self.decode_func=decode_funcs[data_type]
self.db_path=db_path
cache_file=os.path.join(CACHE_FOLDER,map_name(db_path))
if USE_CACHE and os.path.exists(cache_file):
logging.info(f"using local cache {cache_file}")
self.db_path=cache_file
if prefix is None:
self.prefix = None
else:
self.prefix=f"{prefix}_"
self._init=False
preload(self,load=load)
def initialize(self):
self.env = lmdb.open(
self.db_path,
subdir=osp.isdir(self.db_path),
readonly=True,
lock=False,
readahead=False,
meminit=False,
max_readers=10000
)
self._init=True
@property
def keys(self):
while not self._init:
time.sleep(0.1)
if self.prefix is not None:
_keys=[self.prefix+key.decode() for key in get_keys_from_lmdb(self.env)]
else:
_keys=[key.decode() for key in get_keys_from_lmdb(self.env)]
return _keys
def get(self, name):
env = self.env
if self.prefix is not None:
name=remove_prefix(name,self.prefix)
with env.begin(write=False) as txn:
byteflow = txn.get(name.encode())
if byteflow is None:
print("fuck",name)
raise name
return self.decode_func(byteflow)
def __exit__(self, exc_type, exc_value, traceback):
del self.env
import json
class KVReader:
def __init__(self,db_path,data_type,prefix=None,load=True):
assert data_type=="text"
if prefix is None:
self.prefix = None
else:
self.prefix=f"{prefix}_"
self.db_path=db_path
preload(self,load=load)
self._init=False
self._opened=False
def initialize(self):
f=open(self.db_path,"r")
start=int(f.read(1000).strip())
f.seek(start)
self.mp=json.load(f)
if self.prefix is not None:
self.mp={self.prefix+k:v for k,v in self.mp.items()}
f.close()
self._init=True
def open(self):
self.f=open(self.db_path,"r")
self._opened=True
@property
def keys(self):
while not self._init:
time.sleep(0.1)
return list(self.mp.keys())
def get(self,key):
if not self._opened:
self.open()
idx=self.mp[key]
self.f.seek(idx)
text=self.f.readline().strip()
return {"alt_text":text}
def __len__(self):
return len(self.mp)
@staticmethod
def create(file,keys,values):
assert len(keys)==len(values)
f=open(file,"w")
f.write("\n"*1000)
idx=[]
for val in values:
idx.append(f.tell())
f.write(val)
f.write("\n")
start=f.tell()
ki={k:i for i,k in zip(idx,keys)}
json.dump(ki, f, ensure_ascii=False)
f.seek(0)
f.write(str(start))
f.close()
class MultipleLMDBManager:
def __init__(self, files: list, data_type,get_key=False,sync=True):
self.files = files
self._is_init = False
self.data_type=data_type
assert data_type in decode_funcs
self.get_key=get_key
if sync:
print("sync",files)
self.initialize()
else:
print("async",files)
preload(self)
def keep_subset(self,subset):
mapping={key:self.mapping[key] for key in subset}
del self.mapping
self.mapping=mapping
def initialize(self):
self.mapping={}
self.managers={}
new_files=[]
for old_file in self.files:
items=old_file.split("|")
file=items[0]
if len(items)>1:
prefix = items[1]
else:
prefix = None
if not file.startswith("glob-"):
new_files.append(old_file)
else:
desc=remove_prefix(file,"glob-")
sub_files = glob.glob(desc)
sub_files = sorted(sub_files)
if prefix is not None:
sub_files = [f"{f}|{prefix}" for f in sub_files]
new_files.extend(sub_files)
self.files=new_files
for i,old_file in enumerate(self.files):
items=old_file.split("|")
file=items[0]
if len(items)>1:
prefix = items[1]
else:
prefix = None
if file.endswith(".lmdb"):
Manager = DBManager
elif file.endswith(".zip"):
Manager = ZipManager
elif file.endswith(".kv"):
Manager = KVReader
else:
raise
self.managers[i] = Manager(file,self.data_type,prefix=prefix,load=False)
print(file, " done")
ThreadPool(4).run(preload,self.managers.values())
if self.get_key:
self._keys=[]
for index,manager in self.managers.items():
file=manager.db_path
print(f"{file} loading")
logging.info(f"{file} loading")
keys=manager.keys
self._keys.extend(keys)
for key in keys:
self.mapping[key]=index
logging.info(f"{file} loaded, size = {len(keys)}")
print(f"{file} loaded, size = {len(keys)}")
self._is_init=True
@property
def keys(self):
while not self._is_init:
time.sleep(0.1)
return self._keys
def cleanup(self):
del self._keys
del self.mapping
def get(self, name,source=None):
if source is None:
source=self.mapping[name]
data = self.managers[source].get(name)
return data
class MetaDB:
def __init__(self, path, readonly=True, size=None):
self.readonly = readonly
if readonly:
self.db = lmdb.open(
path, readonly=readonly, max_readers=10000, subdir=False, lock=False
)
else:
assert size is not None
self.db = lmdb.open(
path,
readonly=readonly,
max_readers=10000,
subdir=False,
map_size=int(1073741824 * size),
)
def keys(self):
with self.db.begin(write=False) as txn:
keys = list(txn.cursor().iternext(values=False))
return keys
def encode_int(self,num):
return num.to_bytes(4,"big")
def decode_int(self,num_bytes):
return int.from_bytes(num_bytes,"big")
def get(self, key, func=None):
with self.db.begin(write=False) as txn:
val = txn.get(key)
if val is None:
raise
if func:
val = func(val)
return val
| 11,184 | 25.630952 | 122 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/modules/clip/clip.py | import hashlib
import os
import urllib
import warnings
from typing import Union, List
import torch
from PIL import Image
from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize
from tqdm import tqdm
from .model import build_model
from .simple_tokenizer import SimpleTokenizer as _Tokenizer
__all__ = ["available_models", "load", "tokenize"]
_tokenizer = _Tokenizer()
_MODELS = {
"RN50": "https://openaipublic.azureedge.net/clip/models/afeb0e10f9e5a86da6080e35cf09123aca3b358a0c3e3b6c78a7b63bc04b6762/RN50.pt",
"ViT-B/32": "https://openaipublic.azureedge.net/clip/models/40d365715913c9da98579312b702a82c18be219cc2a73407c4526f58eba950af/ViT-B-32.pt",
}
def _download(url: str, root: str = os.path.expanduser("~/.cache/image-synthesis")):
os.makedirs(root, exist_ok=True)
filename = os.path.basename(url)
expected_sha256 = url.split("/")[-2]
# download_target = os.path.join(root, filename)
download_target = "OUTPUT/pretrained_model/ViT-B-32.pt"
if os.path.exists(download_target) and not os.path.isfile(download_target):
raise RuntimeError(f"{download_target} exists and is not a regular file")
if os.path.isfile(download_target):
if hashlib.sha256(open(download_target, "rb").read()).hexdigest() == expected_sha256:
return download_target
else:
warnings.warn(f"{download_target} exists, but the SHA256 checksum does not match; re-downloading the file")
with urllib.request.urlopen(url) as source, open(download_target, "wb") as output:
with tqdm(total=int(source.info().get("Content-Length")), ncols=80, unit='iB', unit_scale=True) as loop:
while True:
buffer = source.read(8192)
if not buffer:
break
output.write(buffer)
loop.update(len(buffer))
if hashlib.sha256(open(download_target, "rb").read()).hexdigest() != expected_sha256:
raise RuntimeError(f"Model has been downloaded but the SHA256 checksum does not not match")
return download_target
def _transform(n_px):
return Compose([
Resize(n_px, interpolation=Image.BICUBIC),
CenterCrop(n_px),
lambda image: image.convert("RGB"),
ToTensor(),
Normalize((0.48145466, 0.4578275, 0.40821073), (0.26862954, 0.26130258, 0.27577711)),
])
def available_models() -> List[str]:
"""Returns the names of available CLIP models"""
return list(_MODELS.keys())
def load(name: str, device: Union[str, torch.device] = "cuda" if torch.cuda.is_available() else "cpu", jit=True):
"""Load a CLIP model
Parameters
----------
name : str
A model name listed by `clip.available_models()`, or the path to a model checkpoint containing the state_dict
device : Union[str, torch.device]
The device to put the loaded model
jit : bool
Whether to load the optimized JIT model (default) or more hackable non-JIT model.
Returns
-------
model : torch.nn.Module
The CLIP model
preprocess : Callable[[PIL.Image], torch.Tensor]
A torchvision transform that converts a PIL image into a tensor that the returned model can take as its input
"""
if name in _MODELS:
# model_path = _download(_MODELS[name])
model_path = "OUTPUT/pretrained_model/ViT-B-32.pt"
elif os.path.isfile(name):
model_path = name
else:
raise RuntimeError(f"Model {name} not found; available models = {available_models()}")
try:
# loading JIT archive
model = torch.jit.load(model_path, map_location=device if jit else "cpu").eval()
state_dict = None
except RuntimeError:
# loading saved state dict
if jit:
warnings.warn(f"File {model_path} is not a JIT archive. Loading as a state dict instead")
jit = False
state_dict = torch.load(model_path, map_location="cpu")
if not jit:
model = build_model(state_dict or model.state_dict()).to(device)
if str(device) == "cpu":
model.float()
return model, _transform(model.visual.input_resolution)
# patch the device names
device_holder = torch.jit.trace(lambda: torch.ones([]).to(torch.device(device)), example_inputs=[])
device_node = [n for n in device_holder.graph.findAllNodes("prim::Constant") if "Device" in repr(n)][-1]
def patch_device(module):
graphs = [module.graph] if hasattr(module, "graph") else []
if hasattr(module, "forward1"):
graphs.append(module.forward1.graph)
for graph in graphs:
for node in graph.findAllNodes("prim::Constant"):
if "value" in node.attributeNames() and str(node["value"]).startswith("cuda"):
node.copyAttributes(device_node)
model.apply(patch_device)
patch_device(model.encode_image)
patch_device(model.encode_text)
# patch dtype to float32 on CPU
if str(device) == "cpu":
float_holder = torch.jit.trace(lambda: torch.ones([]).float(), example_inputs=[])
float_input = list(float_holder.graph.findNode("aten::to").inputs())[1]
float_node = float_input.node()
def patch_float(module):
graphs = [module.graph] if hasattr(module, "graph") else []
if hasattr(module, "forward1"):
graphs.append(module.forward1.graph)
for graph in graphs:
for node in graph.findAllNodes("aten::to"):
inputs = list(node.inputs())
for i in [1, 2]: # dtype can be the second or third argument to aten::to()
if inputs[i].node()["value"] == 5:
inputs[i].node().copyAttributes(float_node)
model.apply(patch_float)
patch_float(model.encode_image)
patch_float(model.encode_text)
model.float()
return model, _transform(model.input_resolution.item())
def tokenize(texts: Union[str, List[str]], context_length: int = 77,
add_start_and_end: bool = True, with_mask: bool = True,
pad_value: int = 0, tokenizer=None, just_token: bool = False) -> torch.LongTensor:
"""
Returns the tokenized representation of given input string(s)
Parameters
----------
texts : Union[str, List[str]]
An input string or a list of input strings to tokenize
context_length : int
The context length to use; all CLIP models use 77 as the context length
just_token: bool
If True, just return the token of text
Returns
-------
A two-dimensional tensor containing the resulting tokens, shape = [number of input strings, context_length]
"""
if isinstance(texts, str):
texts = [texts]
if tokenizer is None:
tokenizer = _tokenizer
sot_token = [tokenizer.encoder["<|startoftext|>"]] if add_start_and_end else []
eot_token = [tokenizer.encoder["<|endoftext|>"]] if add_start_and_end else []
all_tokens = [sot_token + tokenizer.encode(text.lower()) + eot_token for text in texts]
if just_token:
return all_tokens
result = torch.zeros(len(all_tokens), context_length, dtype=torch.long) + pad_value
if with_mask:
mask = torch.zeros(len(all_tokens), context_length, dtype=torch.bool)
for i, tokens in enumerate(all_tokens):
if len(tokens) > context_length:
temp = tokens[-1]
tokens = tokens[:context_length]
tokens[-1] = temp
assert len(tokens) == context_length
# raise RuntimeError("Input text {} is too long for context length {}".format(texts[i], context_length))
result[i, :len(tokens)] = torch.tensor(tokens)
if with_mask:
mask[i, :len(tokens)] = True
results = {
'token': result,
}
if with_mask:
results['mask'] = mask
return results
| 7,962 | 35.360731 | 142 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/modules/clip/model.py | from collections import OrderedDict
from typing import Tuple, Union
import torch
import torch.nn.functional as F
from torch import nn
class Bottleneck(nn.Module):
expansion = 4
def __init__(self, inplanes, planes, stride=1):
super().__init__()
# all conv layers have stride 1. an avgpool is performed after the second convolution when stride > 1
self.conv1 = nn.Conv2d(inplanes, planes, 1, bias=False)
self.bn1 = nn.BatchNorm2d(planes)
self.conv2 = nn.Conv2d(planes, planes, 3, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(planes)
self.avgpool = nn.AvgPool2d(stride) if stride > 1 else nn.Identity()
self.conv3 = nn.Conv2d(planes, planes * self.expansion, 1, bias=False)
self.bn3 = nn.BatchNorm2d(planes * self.expansion)
self.relu = nn.ReLU(inplace=True)
self.downsample = None
self.stride = stride
if stride > 1 or inplanes != planes * Bottleneck.expansion:
# downsampling layer is prepended with an avgpool, and the subsequent convolution has stride 1
self.downsample = nn.Sequential(OrderedDict([
("-1", nn.AvgPool2d(stride)),
("0", nn.Conv2d(inplanes, planes * self.expansion, 1, stride=1, bias=False)),
("1", nn.BatchNorm2d(planes * self.expansion))
]))
def forward(self, x: torch.Tensor):
identity = x
out = self.relu(self.bn1(self.conv1(x)))
out = self.relu(self.bn2(self.conv2(out)))
out = self.avgpool(out)
out = self.bn3(self.conv3(out))
if self.downsample is not None:
identity = self.downsample(x)
out += identity
out = self.relu(out)
return out
class AttentionPool2d(nn.Module):
def __init__(self, spacial_dim: int, embed_dim: int, num_heads: int, output_dim: int = None):
super().__init__()
self.positional_embedding = nn.Parameter(torch.randn(spacial_dim ** 2 + 1, embed_dim) / embed_dim ** 0.5)
self.k_proj = nn.Linear(embed_dim, embed_dim)
self.q_proj = nn.Linear(embed_dim, embed_dim)
self.v_proj = nn.Linear(embed_dim, embed_dim)
self.c_proj = nn.Linear(embed_dim, output_dim or embed_dim)
self.num_heads = num_heads
def forward(self, x):
x = x.reshape(x.shape[0], x.shape[1], x.shape[2] * x.shape[3]).permute(2, 0, 1) # NCHW -> (HW)NC
x = torch.cat([x.mean(dim=0, keepdim=True), x], dim=0) # (HW+1)NC
x = x + self.positional_embedding[:, None, :].to(x.dtype) # (HW+1)NC
x, _ = F.multi_head_attention_forward(
query=x, key=x, value=x,
embed_dim_to_check=x.shape[-1],
num_heads=self.num_heads,
q_proj_weight=self.q_proj.weight,
k_proj_weight=self.k_proj.weight,
v_proj_weight=self.v_proj.weight,
in_proj_weight=None,
in_proj_bias=torch.cat([self.q_proj.bias, self.k_proj.bias, self.v_proj.bias]),
bias_k=None,
bias_v=None,
add_zero_attn=False,
dropout_p=0,
out_proj_weight=self.c_proj.weight,
out_proj_bias=self.c_proj.bias,
use_separate_proj_weight=True,
training=self.training,
need_weights=False
)
return x[0]
class ModifiedResNet(nn.Module):
"""
A ResNet class that is similar to torchvision's but contains the following changes:
- There are now 3 "stem" convolutions as opposed to 1, with an average pool instead of a max pool.
- Performs anti-aliasing strided convolutions, where an avgpool is prepended to convolutions with stride > 1
- The final pooling layer is a QKV attention instead of an average pool
"""
def __init__(self, layers, output_dim, heads, input_resolution=224, width=64):
super().__init__()
self.output_dim = output_dim
self.input_resolution = input_resolution
# the 3-layer stem
self.conv1 = nn.Conv2d(3, width // 2, kernel_size=3, stride=2, padding=1, bias=False)
self.bn1 = nn.BatchNorm2d(width // 2)
self.conv2 = nn.Conv2d(width // 2, width // 2, kernel_size=3, padding=1, bias=False)
self.bn2 = nn.BatchNorm2d(width // 2)
self.conv3 = nn.Conv2d(width // 2, width, kernel_size=3, padding=1, bias=False)
self.bn3 = nn.BatchNorm2d(width)
self.avgpool = nn.AvgPool2d(2)
self.relu = nn.ReLU(inplace=True)
# residual layers
self._inplanes = width # this is a *mutable* variable used during construction
self.layer1 = self._make_layer(width, layers[0])
self.layer2 = self._make_layer(width * 2, layers[1], stride=2)
self.layer3 = self._make_layer(width * 4, layers[2], stride=2)
self.layer4 = self._make_layer(width * 8, layers[3], stride=2)
embed_dim = width * 32 # the ResNet feature dimension
self.attnpool = AttentionPool2d(input_resolution // 32, embed_dim, heads, output_dim)
def _make_layer(self, planes, blocks, stride=1):
layers = [Bottleneck(self._inplanes, planes, stride)]
self._inplanes = planes * Bottleneck.expansion
for _ in range(1, blocks):
layers.append(Bottleneck(self._inplanes, planes))
return nn.Sequential(*layers)
def forward(self, x):
def stem(x):
for conv, bn in [(self.conv1, self.bn1), (self.conv2, self.bn2), (self.conv3, self.bn3)]:
x = self.relu(bn(conv(x)))
x = self.avgpool(x)
return x
x = x.type(self.conv1.weight.dtype)
x = stem(x)
x = self.layer1(x)
x = self.layer2(x)
x = self.layer3(x)
x = self.layer4(x)
x = self.attnpool(x)
return x
class LayerNorm(nn.LayerNorm):
"""Subclass torch's LayerNorm to handle fp16."""
def forward(self, x: torch.Tensor):
orig_type = x.dtype
ret = super().forward(x.type(torch.float32))
return ret.type(orig_type)
class QuickGELU(nn.Module):
def forward(self, x: torch.Tensor):
return x * torch.sigmoid(1.702 * x)
class ResidualAttentionBlock(nn.Module):
def __init__(self, d_model: int, n_head: int, attn_mask: torch.Tensor = None):
super().__init__()
self.attn = nn.MultiheadAttention(d_model, n_head)
self.ln_1 = LayerNorm(d_model)
self.mlp = nn.Sequential(OrderedDict([
("c_fc", nn.Linear(d_model, d_model * 4)),
("gelu", QuickGELU()),
("c_proj", nn.Linear(d_model * 4, d_model))
]))
self.ln_2 = LayerNorm(d_model)
self.attn_mask = attn_mask
def attention(self, x: torch.Tensor):
self.attn_mask = self.attn_mask.to(dtype=x.dtype, device=x.device) if self.attn_mask is not None else None
return self.attn(x, x, x, need_weights=False, attn_mask=self.attn_mask)[0]
def forward(self, x: torch.Tensor):
x = x + self.attention(self.ln_1(x))
x = x + self.mlp(self.ln_2(x))
return x
class Transformer(nn.Module):
def __init__(self, width: int, layers: int, heads: int, attn_mask: torch.Tensor = None):
super().__init__()
self.width = width
self.layers = layers
self.resblocks = nn.Sequential(*[ResidualAttentionBlock(width, heads, attn_mask) for _ in range(layers)])
def forward(self, x: torch.Tensor):
return self.resblocks(x)
class VisualTransformer(nn.Module):
def __init__(self, input_resolution: int, patch_size: int, width: int, layers: int, heads: int, output_dim: int):
super().__init__()
self.input_resolution = input_resolution
self.output_dim = output_dim
self.conv1 = nn.Conv2d(in_channels=3, out_channels=width, kernel_size=patch_size, stride=patch_size, bias=False)
scale = width ** -0.5
self.class_embedding = nn.Parameter(scale * torch.randn(width))
self.positional_embedding = nn.Parameter(scale * torch.randn((input_resolution // patch_size) ** 2 + 1, width))
self.ln_pre = LayerNorm(width)
self.transformer = Transformer(width, layers, heads)
self.ln_post = LayerNorm(width)
self.proj = nn.Parameter(scale * torch.randn(width, output_dim))
def forward(self, x: torch.Tensor):
x = self.conv1(x) # shape = [*, width, grid, grid]
x = x.reshape(x.shape[0], x.shape[1], -1) # shape = [*, width, grid ** 2]
x = x.permute(0, 2, 1) # shape = [*, grid ** 2, width]
x = torch.cat([self.class_embedding.to(x.dtype) + torch.zeros(x.shape[0], 1, x.shape[-1], dtype=x.dtype, device=x.device), x], dim=1) # shape = [*, grid ** 2 + 1, width]
x = x + self.positional_embedding.to(x.dtype)
x = self.ln_pre(x)
x = x.permute(1, 0, 2) # NLD -> LND
x = self.transformer(x)
x = x.permute(1, 0, 2) # LND -> NLD
x = self.ln_post(x[:, 0, :])
if self.proj is not None:
x = x @ self.proj
return x
class CLIP(nn.Module):
def __init__(self,
embed_dim: int,
# vision
image_resolution: int,
vision_layers: Union[Tuple[int, int, int, int], int],
vision_width: int,
vision_patch_size: int,
# text
context_length: int,
vocab_size: int,
transformer_width: int,
transformer_heads: int,
transformer_layers: int
):
super().__init__()
self.context_length = context_length
if isinstance(vision_layers, (tuple, list)):
vision_heads = vision_width * 32 // 64
self.visual = ModifiedResNet(
layers=vision_layers,
output_dim=embed_dim,
heads=vision_heads,
input_resolution=image_resolution,
width=vision_width
)
else:
vision_heads = vision_width // 64
self.visual = VisualTransformer(
input_resolution=image_resolution,
patch_size=vision_patch_size,
width=vision_width,
layers=vision_layers,
heads=vision_heads,
output_dim=embed_dim
)
self.transformer = Transformer(
width=transformer_width,
layers=transformer_layers,
heads=transformer_heads,
attn_mask=self.build_attention_mask()
)
self.vocab_size = vocab_size
self.token_embedding = nn.Embedding(vocab_size, transformer_width)
self.positional_embedding = nn.Parameter(torch.empty(self.context_length, transformer_width))
self.ln_final = LayerNorm(transformer_width)
self.text_projection = nn.Parameter(torch.empty(transformer_width, embed_dim))
self.logit_scale = nn.Parameter(torch.ones([]))
self.initialize_parameters()
def initialize_parameters(self):
nn.init.normal_(self.token_embedding.weight, std=0.02)
nn.init.normal_(self.positional_embedding, std=0.01)
if isinstance(self.visual, ModifiedResNet):
if self.visual.attnpool is not None:
std = self.visual.attnpool.c_proj.in_features ** -0.5
nn.init.normal_(self.visual.attnpool.q_proj.weight, std=std)
nn.init.normal_(self.visual.attnpool.k_proj.weight, std=std)
nn.init.normal_(self.visual.attnpool.v_proj.weight, std=std)
nn.init.normal_(self.visual.attnpool.c_proj.weight, std=std)
for resnet_block in [self.visual.layer1, self.visual.layer2, self.visual.layer3, self.visual.layer4]:
for name, param in resnet_block.named_parameters():
if name.endswith("bn3.weight"):
nn.init.zeros_(param)
proj_std = (self.transformer.width ** -0.5) * ((2 * self.transformer.layers) ** -0.5)
attn_std = self.transformer.width ** -0.5
fc_std = (2 * self.transformer.width) ** -0.5
for block in self.transformer.resblocks:
nn.init.normal_(block.attn.in_proj_weight, std=attn_std)
nn.init.normal_(block.attn.out_proj.weight, std=proj_std)
nn.init.normal_(block.mlp.c_fc.weight, std=fc_std)
nn.init.normal_(block.mlp.c_proj.weight, std=proj_std)
if self.text_projection is not None:
nn.init.normal_(self.text_projection, std=self.transformer.width ** -0.5)
def build_attention_mask(self):
# lazily create causal attention mask, with full attention between the vision tokens
# pytorch uses additive attention mask; fill with -inf
mask = torch.empty(self.context_length, self.context_length)
mask.fill_(float("-inf"))
mask.triu_(1) # zero out the lower diagonal
return mask
@property
def dtype(self):
if hasattr(self, 'visual'):
return self.visual.conv1.weight.dtype
else:
return self.transformer.resblocks[0].attn.in_proj_weight.dtype
def encode_image(self, image):
return self.visual(image.type(self.dtype))
def encode_text(self, text):
x = self.token_embedding(text).type(self.dtype) # [batch_size, n_ctx, d_model]
x = x + self.positional_embedding.type(self.dtype)
x = x.permute(1, 0, 2) # NLD -> LND
x = self.transformer(x)
x = x.permute(1, 0, 2) # LND -> NLD
x = self.ln_final(x).type(self.dtype)
# x.shape = [batch_size, n_ctx, transformer.width]
# take features from the eot embedding (eot_token is the highest number in each sequence)
x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection
return x
def forward(self, image, text):
image_features = self.encode_image(image)
text_features = self.encode_text(text)
# normalized features
image_features = image_features / image_features.norm(dim=-1, keepdim=True)
text_features = text_features / text_features.norm(dim=-1, keepdim=True)
# cosine similarity as logits
logit_scale = self.logit_scale.exp()
logits_per_image = logit_scale * image_features @ text_features.t()
logits_per_text = logit_scale * text_features @ image_features.t()
# shape = [global_batch_size, global_batch_size]
return logits_per_image, logits_per_text
def convert_weights(model: nn.Module):
"""Convert applicable model parameters to fp16"""
def _convert_weights_to_fp16(l):
if isinstance(l, (nn.Conv1d, nn.Conv2d, nn.Linear)):
l.weight.data = l.weight.data.half()
if l.bias is not None:
l.bias.data = l.bias.data.half()
if isinstance(l, nn.MultiheadAttention):
for attr in [*[f"{s}_proj_weight" for s in ["in", "q", "k", "v"]], "in_proj_bias", "bias_k", "bias_v"]:
tensor = getattr(l, attr)
if tensor is not None:
tensor.data = tensor.data.half()
for name in ["text_projection", "proj"]:
if hasattr(l, name):
attr = getattr(l, name)
if attr is not None:
attr.data = attr.data.half()
model.apply(_convert_weights_to_fp16)
def build_model(state_dict: dict):
vit = "visual.proj" in state_dict
if vit:
vision_width = state_dict["visual.conv1.weight"].shape[0]
vision_layers = len([k for k in state_dict.keys() if k.startswith("visual.") and k.endswith(".attn.in_proj_weight")])
vision_patch_size = state_dict["visual.conv1.weight"].shape[-1]
grid_size = round((state_dict["visual.positional_embedding"].shape[0] - 1) ** 0.5)
image_resolution = vision_patch_size * grid_size
else:
counts: list = [len(set(k.split(".")[2] for k in state_dict if k.startswith(f"visual.layer{b}"))) for b in [1, 2, 3, 4]]
vision_layers = tuple(counts)
vision_width = state_dict["visual.layer1.0.conv1.weight"].shape[0]
output_width = round((state_dict["visual.attnpool.positional_embedding"].shape[0] - 1) ** 0.5)
vision_patch_size = None
assert output_width ** 2 + 1 == state_dict["visual.attnpool.positional_embedding"].shape[0]
image_resolution = output_width * 32
embed_dim = state_dict["text_projection"].shape[1]
context_length = state_dict["positional_embedding"].shape[0]
vocab_size = state_dict["token_embedding.weight"].shape[0]
transformer_width = state_dict["ln_final.weight"].shape[0]
transformer_heads = transformer_width // 64
transformer_layers = len(set(k.split(".")[2] for k in state_dict if k.startswith(f"transformer.resblocks")))
model = CLIP(
embed_dim,
image_resolution, vision_layers, vision_width, vision_patch_size,
context_length, vocab_size, transformer_width, transformer_heads, transformer_layers
)
for key in ["input_resolution", "context_length", "vocab_size"]:
if key in state_dict:
del state_dict[key]
convert_weights(model)
model.load_state_dict(state_dict)
return model.eval()
| 17,333 | 38.848276 | 178 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/codecs/base_codec.py | import torch
from torch import nn
class BaseCodec(nn.Module):
def get_tokens(self, x, **kwargs):
"""
Input:
x: input data
Return:
indices: B x L, the codebook indices, where L is the length
of flattened feature map size
"""
raise NotImplementedError
def get_number_of_tokens(self):
"""
Return: int, the number of tokens
"""
raise NotImplementedError
def encode(self, img):
raise NotImplementedError
def decode(self, img_seq):
raise NotImplementedError
def forward(self, **kwargs):
raise NotImplementedError
def train(self, mode=True):
self.training = mode
if self.trainable and mode:
return super().train(True)
else:
return super().train(False)
def _set_trainable(self):
if not self.trainable:
for pn, p in self.named_parameters():
p.requires_grad = False
self.eval() | 1,046 | 23.348837 | 72 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/codecs/image_codec/taming_gumbel_vqvae.py | import torch
import torch.nn as nn
from omegaconf import OmegaConf
import sys
sys.path.append("..")
# sys.path.append("../image_synthesis")
from image_synthesis.utils.misc import instantiate_from_config
from image_synthesis.taming.models.vqgan import GumbelVQ, VQModel
from image_synthesis.taming.models.cond_transformer import Net2NetTransformer
import os
import torchvision.transforms.functional as TF
import PIL
from image_synthesis.modeling.codecs.base_codec import BaseCodec
from einops import rearrange
import math
class Encoder(nn.Module):
def __init__(self, encoder, quant_conv, quantize):
super().__init__()
self.encoder = encoder
self.quant_conv = quant_conv
self.quantize = quantize
@torch.no_grad()
def forward(self, x):
x = 2*x - 1
h = self.encoder(x)
h = self.quant_conv(h)
quant, _, [_, _, indices] = self.quantize(h)
return indices.view(x.shape[0], -1)
class Decoder(nn.Module):
def __init__(self, decoder, post_quant_conv, quantize, w=16, h=16):
super().__init__()
self.decoder = decoder
self.post_quant_conv = post_quant_conv
self.quantize = quantize
self.w = w
self.h = h
@torch.no_grad()
def forward(self, indices):
z = self.quantize.get_codebook_entry(indices.view(-1), shape=(indices.shape[0], self.h, self.w, -1))
quant = self.post_quant_conv(z)
dec = self.decoder(quant)
x = torch.clamp(dec, -1., 1.)
x = (x + 1.)/2.
return x
class TamingFFHQVQVAE(BaseCodec):
def __init__(
self,
trainable=False,
token_shape=[16,16],
config_path='OUTPUT/pretrained_model/taming_dvae/vqgan_ffhq_f16_1024.yaml',
ckpt_path='OUTPUT/pretrained_model/taming_dvae/vqgan_ffhq_f16_1024.pth',
num_tokens=1024,
quantize_number=0,
mapping_path=None,
):
super().__init__()
model = self.LoadModel(config_path, ckpt_path)
self.enc = Encoder(model.encoder, model.quant_conv, model.quantize)
self.dec = Decoder(model.decoder, model.post_quant_conv, model.quantize, token_shape[0], token_shape[1])
self.num_tokens = num_tokens
self.quantize_number = quantize_number
if self.quantize_number != 0 and mapping_path!=None:
self.full_to_quantize = torch.load(mapping_path)
self.quantize_to_full = torch.zeros(self.quantize_number)-1
for idx, i in enumerate(self.full_to_quantize):
if self.quantize_to_full[i] == -1:
self.quantize_to_full[i] = idx
self.quantize_to_full = self.quantize_to_full.long()
self.trainable = trainable
self.token_shape = token_shape
self._set_trainable()
def LoadModel(self, config_path, ckpt_path):
config = OmegaConf.load(config_path)
# model = instantiate_from_config(config.model)
model = Net2NetTransformer(**config.model.params)
sd = torch.load(ckpt_path, map_location="cpu")["state_dict"]
model.load_state_dict(sd, strict=False)
if (isinstance(model, Net2NetTransformer)):
model = model.first_stage_model
return model
@property
def device(self):
# import pdb; pdb.set_trace()
return self.enc.quant_conv.weight.device
def preprocess(self, imgs):
"""
imgs: B x C x H x W, in the range 0-255
"""
imgs = imgs.div(255) # map to 0 - 1
return imgs
# return map_pixels(imgs)
def postprocess(self, imgs):
"""
imgs: B x C x H x W, in the range 0-1
"""
imgs = imgs * 255
return imgs
def get_tokens(self, imgs, **kwargs):
imgs = self.preprocess(imgs)
code = self.enc(imgs)
if self.quantize_number != 0:
code = self.full_to_quantize[code]
output = {'token': code}
# output = {'token': rearrange(code, 'b h w -> b (h w)')}
return output
def decode(self, img_seq):
if self.quantize_number != 0:
img_seq=self.quantize_to_full[img_seq].type_as(img_seq)
b, n = img_seq.shape
img_seq = rearrange(img_seq, 'b (h w) -> b h w', h = int(math.sqrt(n)))
x_rec = self.dec(img_seq)
x_rec = self.postprocess(x_rec)
return x_rec
class TamingVQVAE(BaseCodec):
def __init__(
self,
trainable=False,
token_shape=[16,16],
config_path='OUTPUT/pretrained_model/taming_dvae/vqgan_imagenet_f16_16384.yaml',
ckpt_path='OUTPUT/pretrained_model/taming_dvae/vqgan_imagenet_f16_16384.pth',
num_tokens=16384,
quantize_number=974,
mapping_path='./help_folder/statistics/taming_vqvae_974.pt',
):
super().__init__()
model = self.LoadModel(config_path, ckpt_path)
self.enc = Encoder(model.encoder, model.quant_conv, model.quantize)
self.dec = Decoder(model.decoder, model.post_quant_conv, model.quantize, token_shape[0], token_shape[1])
self.num_tokens = num_tokens
self.quantize_number = quantize_number
if self.quantize_number != 0 and mapping_path!=None:
self.full_to_quantize = torch.load(mapping_path)
self.quantize_to_full = torch.zeros(self.quantize_number)-1
for idx, i in enumerate(self.full_to_quantize):
if self.quantize_to_full[i] == -1:
self.quantize_to_full[i] = idx
self.quantize_to_full = self.quantize_to_full.long()
self.trainable = trainable
self.token_shape = token_shape
self._set_trainable()
def LoadModel(self, config_path, ckpt_path):
config = OmegaConf.load(config_path)
model = VQModel(**config.model.params)
sd = torch.load(ckpt_path, map_location="cpu")["state_dict"]
model.load_state_dict(sd, strict=False)
return model
@property
def device(self):
# import pdb; pdb.set_trace()
return self.enc.quant_conv.weight.device
def preprocess(self, imgs):
"""
imgs: B x C x H x W, in the range 0-255
"""
imgs = imgs.div(255) # map to 0 - 1
return imgs
# return map_pixels(imgs)
def postprocess(self, imgs):
"""
imgs: B x C x H x W, in the range 0-1
"""
imgs = imgs * 255
return imgs
def get_tokens(self, imgs, **kwargs):
imgs = self.preprocess(imgs)
code = self.enc(imgs)
if self.quantize_number != 0:
code = self.full_to_quantize[code]
output = {'token': code}
# output = {'token': rearrange(code, 'b h w -> b (h w)')}
return output
def decode(self, img_seq):
if self.quantize_number != 0:
img_seq=self.quantize_to_full[img_seq].type_as(img_seq)
b, n = img_seq.shape
img_seq = rearrange(img_seq, 'b (h w) -> b h w', h = int(math.sqrt(n)))
x_rec = self.dec(img_seq)
x_rec = self.postprocess(x_rec)
return x_rec
class TamingGumbelVQVAE(BaseCodec):
def __init__(
self,
trainable=False,
token_shape=[32,32],
config_path='OUTPUT/pretrained_model/taming_dvae/taming_f8_8192_openimages.yaml',
ckpt_path='OUTPUT/pretrained_model/taming_dvae/taming_f8_8192_openimages_last.pth',
num_tokens=8192,
quantize_number=2887,
mapping_path='./help_folder/statistics/taming_vqvae_2887.pt',
):
super().__init__()
model = self.LoadModel(config_path, ckpt_path)
self.enc = Encoder(model.encoder, model.quant_conv, model.quantize)
self.dec = Decoder(model.decoder, model.post_quant_conv, model.quantize, token_shape[0], token_shape[1])
self.num_tokens = num_tokens
self.quantize_number = quantize_number
if self.quantize_number != 0 and mapping_path!=None:
self.full_to_quantize = torch.load(mapping_path)
self.quantize_to_full = torch.zeros(self.quantize_number)-1
for idx, i in enumerate(self.full_to_quantize):
if self.quantize_to_full[i] == -1:
self.quantize_to_full[i] = idx
self.quantize_to_full = self.quantize_to_full.long()
self.trainable = trainable
self.token_shape = token_shape
self._set_trainable()
def LoadModel(self, config_path, ckpt_path):
config = OmegaConf.load(config_path)
model = GumbelVQ(**config.model.params)
sd = torch.load(ckpt_path, map_location="cpu")["state_dict"]
model.load_state_dict(sd, strict=False)
return model
@property
def device(self):
# import pdb; pdb.set_trace()
return self.enc.quant_conv.weight.device
def preprocess(self, imgs):
"""
imgs: B x C x H x W, in the range 0-255
"""
imgs = imgs.div(255) # map to 0 - 1
return imgs
# return map_pixels(imgs)
def postprocess(self, imgs):
"""
imgs: B x C x H x W, in the range 0-1
"""
imgs = imgs * 255
return imgs
def get_tokens(self, imgs, **kwargs):
imgs = self.preprocess(imgs)
code = self.enc(imgs)
if self.quantize_number != 0:
code = self.full_to_quantize[code]
output = {'token': code}
# output = {'token': rearrange(code, 'b h w -> b (h w)')}
return output
def decode(self, img_seq):
if self.quantize_number != 0:
img_seq=self.quantize_to_full[img_seq].type_as(img_seq)
b, n = img_seq.shape
img_seq = rearrange(img_seq, 'b (h w) -> b h w', h = int(math.sqrt(n)))
x_rec = self.dec(img_seq)
x_rec = self.postprocess(x_rec)
return x_rec
| 10,011 | 33.885017 | 112 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/codecs/image_codec/patch_vqgan.py | from numpy.core.shape_base import block
from numpy.lib import stride_tricks
import torch
import numpy as np
import torch.nn as nn
import torch.nn.functional as F
import random
from torch.nn.modules.linear import Linear
from image_synthesis.utils.misc import instantiate_from_config
from image_synthesis.modeling.codecs.base_codec import BaseCodec
# from image_synthesis.modeling.modules.vqgan_loss.vqperceptual import VQLPIPSWithDiscriminator
from image_synthesis.modeling.utils.misc import mask_with_top_k, logits_top_k, get_token_type
from image_synthesis.distributed.distributed import all_reduce
# class for quantization
# class for quantization
class EMAVectorQuantizer(nn.Module):
"""
see https://github.com/MishaLaskin/vqvae/blob/d761a999e2267766400dc646d82d3ac3657771d4/models/quantizer.py
____________________________________________
Discretization bottleneck part of the VQ-VAE.
Inputs:
- n_e : number of embeddings
- e_dim : dimension of embedding
- beta : commitment cost used in loss term, beta * ||z_e(x)-sg[e]||^2
_____________________________________________
"""
def __init__(self, n_e, e_dim, beta,
masked_n_e_ratio=0,#1.0/4,
embed_init_scale=1.0,
decay = 0.99,
embed_ema=True,
get_embed_type='retrive',
distance_type='euclidean',
):
super(EMAVectorQuantizer, self).__init__()
self.n_e = n_e
self.masked_n_e_ratio = masked_n_e_ratio
self.e_dim = e_dim
self.beta = beta
self.decay = decay
self.embed_ema = embed_ema
self.get_embed_type = get_embed_type
self.distance_type = distance_type
if self.embed_ema:
self.eps = 1.0e-5
embed = torch.randn(n_e, e_dim)
# embed = torch.zeros(n_e, e_dim)
# embed.data.uniform_(-embed_init_scale / self.n_e, embed_init_scale / self.n_e)
self.register_buffer("embedding", embed)
self.register_buffer("cluster_size", torch.zeros(n_e))
self.register_buffer("embedding_avg", embed.clone())
else:
self.embedding = nn.Embedding(self.n_e, self.e_dim)
self.embedding.weight.data.uniform_(-embed_init_scale / self.n_e, embed_init_scale / self.n_e)
self.masked_embed_start = self.n_e - int(self.masked_n_e_ratio * self.n_e)
if self.distance_type == 'learned':
self.distance_fc = nn.Linear(self.e_dim, self.n_e)
@property
def norm_feat(self):
return self.distance_type in ['cosine', 'sinkhorn']
@property
def embed_weight(self):
if isinstance(self.embedding, nn.Embedding):
return self.embedding.weight
else:
return self.embedding
def norm_embedding(self):
if self.training:
with torch.no_grad():
w = self.embed_weight.data.clone()
w = F.normalize(w, dim=1, p=2)
if isinstance(self.embedding, nn.Embedding):
self.embedding.weight.copy_(w)
else:
self.embedding.copy_(w)
def _quantize(self, z, token_type=None):
"""
z: L x D
token_type: L, 1 denote unmasked token, other masked token
"""
if self.distance_type == 'euclidean':
d = torch.sum(z ** 2, dim=1, keepdim=True) + \
torch.sum(self.embed_weight**2, dim=1) - 2 * \
torch.matmul(z, self.embed_weight.t())
elif self.distance_type == 'cosine':
d = 0 - torch.einsum('ld,nd->ln', z, self.embed_weight) # BHW x N
else:
raise NotImplementedError('distance not implemented for {}'.format(self.distance_type))
# find closest encodings
# import pdb; pdb.set_trace()
if token_type is None or self.masked_embed_start == self.n_e:
min_encoding_indices = torch.argmin(d, dim=1) # L
else:
min_encoding_indices = torch.zeros(z.shape[0]).long().to(z.device)
idx = token_type == 1
if idx.sum() > 0:
d_ = d[idx][:, :self.masked_embed_start] # l x n
indices_ = torch.argmin(d_, dim=1)
min_encoding_indices[idx] = indices_
idx = token_type != 1
if idx.sum() > 0:
d_ = d[idx][:, self.masked_embed_start:] # l x n
indices_ = torch.argmin(d_, dim=1) + self.masked_embed_start
min_encoding_indices[idx] = indices_
if self.get_embed_type == 'matmul':
min_encodings = torch.zeros(min_encoding_indices.shape[0], self.n_e).to(z)
min_encodings.scatter_(1, min_encoding_indices.unsqueeze(1), 1)
# import pdb; pdb.set_trace()
z_q = torch.matmul(min_encodings, self.embed_weight)#.view(z.shape)
elif self.get_embed_type == 'retrive':
z_q = F.embedding(min_encoding_indices, self.embed_weight)#.view(z.shape)
else:
raise NotImplementedError
return z_q, min_encoding_indices
def forward(self, z, token_type=None):
"""
z: B x C x H x W
token_type: B x 1 x H x W
"""
if self.distance_type in ['sinkhorn', 'cosine']:
# need to norm feat and weight embedding
self.norm_embedding()
z = F.normalize(z, dim=1, p=2)
# reshape z -> (batch, height, width, channel) and flatten
batch_size, _, height, width = z.shape
# import pdb; pdb.set_trace()
z = z.permute(0, 2, 3, 1).contiguous() # B x H x W x C
z_flattened = z.view(-1, self.e_dim) # BHW x C
if token_type is not None:
token_type_flattened = token_type.view(-1)
else:
token_type_flattened = None
z_q, min_encoding_indices = self._quantize(z_flattened, token_type_flattened)
z_q = z_q.view(batch_size, height, width, -1) #.permute(0, 2, 3, 1).contiguous()
if self.training and self.embed_ema:
# import pdb; pdb.set_trace()
assert self.distance_type in ['euclidean', 'cosine']
indices_onehot = F.one_hot(min_encoding_indices, self.n_e).to(z_flattened.dtype) # L x n_e
indices_onehot_sum = indices_onehot.sum(0) # n_e
z_sum = (z_flattened.transpose(0, 1) @ indices_onehot).transpose(0, 1) # n_e x D
all_reduce(indices_onehot_sum)
all_reduce(z_sum)
self.cluster_size.data.mul_(self.decay).add_(indices_onehot_sum, alpha=1 - self.decay)
self.embedding_avg.data.mul_(self.decay).add_(z_sum, alpha=1 - self.decay)
n = self.cluster_size.sum()
cluster_size = (self.cluster_size + self.eps) / (n + self.n_e * self.eps) * n
embed_normalized = self.embedding_avg / cluster_size.unsqueeze(1)
self.embedding.data.copy_(embed_normalized)
# print((self.embed > 1.0e-20).abs().sum())
if self.embed_ema:
loss = (z_q.detach() - z).pow(2).mean()
else:
# compute loss for embedding
loss = torch.mean((z_q.detach()-z).pow(2)) + self.beta * torch.mean((z_q - z.detach()).pow(2))
# preserve gradients
z_q = z + (z_q - z).detach()
# reshape back to match original input shape
z_q = z_q.permute(0, 3, 1, 2).contiguous()
# used_quantize_embed = torch.zeros_like(loss) + min_encoding_indices.unique().shape[0]
# used_quantize_embed = all_reduce(used_quantize_embed) / get_world_size()
output = {
'quantize': z_q,
'used_quantize_embed': torch.zeros_like(loss) + min_encoding_indices.unique().shape[0],
'quantize_loss': loss,
'index': min_encoding_indices.view(batch_size, height, width)
}
if token_type_flattened is not None:
unmasked_num_token = all_reduce((token_type_flattened == 1).sum())
masked_num_token = all_reduce((token_type_flattened != 1).sum())
output['unmasked_num_token'] = unmasked_num_token
output['masked_num_token'] = masked_num_token
return output
def only_get_indices(self, z, token_type=None):
"""
z: B x C x H x W
token_type: B x 1 x H x W
"""
if self.distance_type in ['sinkhorn', 'cosine']:
# need to norm feat and weight embedding
self.norm_embedding()
z = F.normalize(z, dim=1, p=2)
# reshape z -> (batch, height, width, channel) and flatten
batch_size, _, height, width = z.shape
# import pdb; pdb.set_trace()
z = z.permute(0, 2, 3, 1).contiguous() # B x H x W x C
z_flattened = z.view(-1, self.e_dim) # BHW x C
if token_type is not None:
token_type_flattened = token_type.view(-1)
else:
token_type_flattened = None
_, min_encoding_indices = self._quantize(z_flattened, token_type_flattened)
min_encoding_indices = min_encoding_indices.view(batch_size, height, width)
return min_encoding_indices
def get_codebook_entry(self, indices, shape):
# import pdb; pdb.set_trace()
# shape specifying (batch, height, width)
if self.get_embed_type == 'matmul':
min_encodings = torch.zeros(indices.shape[0], self.n_e).to(indices)
min_encodings.scatter_(1, indices[:,None], 1)
# get quantized latent vectors
z_q = torch.matmul(min_encodings.float(), self.embed_weight)
elif self.get_embed_type == 'retrive':
z_q = F.embedding(indices, self.embed_weight)
else:
raise NotImplementedError
if shape is not None:
z_q = z_q.view(*shape, -1) # B x H x W x C
if len(z_q.shape) == 4:
# reshape back to match original input shape
z_q = z_q.permute(0, 3, 1, 2).contiguous()
return z_q
# blocks for encoder and decoder
def Normalize(in_channels):
return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
def nonlinearity(x):
# swish
return x*torch.sigmoid(x)
class Upsample(nn.Module):
def __init__(self, in_channels, with_conv, upsample_type='interpolate'):
super().__init__()
self.upsample_type = upsample_type
self.with_conv = with_conv
if self.upsample_type == 'conv':
self.sample = nn.ConvTranspose2d(in_channels, in_channels, kernel_size=4, stride=2, padding=1),
if self.with_conv:
self.conv = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1)
def forward(self, x):
if self.upsample_type == 'conv':
x = self.sample(x)
else:
x = torch.nn.functional.interpolate(x, scale_factor=2.0, mode="nearest")
if self.with_conv:
x = self.conv(x)
return x
class ResnetBlock(nn.Module):
def __init__(self, *, in_channels, out_channels=None, conv_shortcut=False,
dropout=0.0, temb_channels=512):
super().__init__()
self.in_channels = in_channels
out_channels = in_channels if out_channels is None else out_channels
self.out_channels = out_channels
self.use_conv_shortcut = conv_shortcut
self.norm1 = Normalize(in_channels)
self.conv1 = torch.nn.Conv2d(in_channels,
out_channels,
kernel_size=3,
stride=1,
padding=1)
if temb_channels > 0:
self.temb_proj = torch.nn.Linear(temb_channels,
out_channels)
self.norm2 = Normalize(out_channels)
self.dropout = torch.nn.Dropout(dropout)
self.conv2 = torch.nn.Conv2d(out_channels,
out_channels,
kernel_size=3,
stride=1,
padding=1)
if self.in_channels != self.out_channels:
if self.use_conv_shortcut:
self.conv_shortcut = torch.nn.Conv2d(in_channels,
out_channels,
kernel_size=3,
stride=1,
padding=1)
else:
self.nin_shortcut = torch.nn.Conv2d(in_channels,
out_channels,
kernel_size=1,
stride=1,
padding=0)
def forward(self, x, temb):
h = x
h = self.norm1(h)
h = nonlinearity(h)
h = self.conv1(h)
if temb is not None:
h = h + self.temb_proj(nonlinearity(temb))[:,:,None,None]
h = self.norm2(h)
h = nonlinearity(h)
h = self.dropout(h)
h = self.conv2(h)
if self.in_channels != self.out_channels:
if self.use_conv_shortcut:
x = self.conv_shortcut(x)
else:
x = self.nin_shortcut(x)
return x+h
class AttnBlock(nn.Module):
def __init__(self, in_channels):
super().__init__()
self.in_channels = in_channels
self.norm = Normalize(in_channels)
self.q = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=1,
stride=1,
padding=0)
self.k = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=1,
stride=1,
padding=0)
self.v = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=1,
stride=1,
padding=0)
self.proj_out = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=1,
stride=1,
padding=0)
def forward(self, x):
h_ = x
h_ = self.norm(h_)
q = self.q(h_)
k = self.k(h_)
v = self.v(h_)
# compute attention
b,c,h,w = q.shape
q = q.reshape(b,c,h*w)
q = q.permute(0,2,1) # b,hw,c
k = k.reshape(b,c,h*w) # b,c,hw
w_ = torch.bmm(q,k) # b,hw,hw w[b,i,j]=sum_c q[b,i,c]k[b,c,j]
w_ = w_ * (int(c)**(-0.5))
w_ = torch.nn.functional.softmax(w_, dim=2)
# attend to values
v = v.reshape(b,c,h*w)
w_ = w_.permute(0,2,1) # b,hw,hw (first hw of k, second of q)
h_ = torch.bmm(v,w_) # b, c,hw (hw of q) h_[b,c,j] = sum_i v[b,c,i] w_[b,i,j]
h_ = h_.reshape(b,c,h,w)
h_ = self.proj_out(h_)
return x+h_
class Downsample(nn.Module):
def __init__(self, in_channels, with_conv):
super().__init__()
self.with_conv = with_conv
if self.with_conv:
# no asymmetric padding in torch conv, must do it ourselves
self.conv = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=2,
padding=0)
def forward(self, x):
if self.with_conv:
pad = (0,1,0,1)
x = torch.nn.functional.pad(x, pad, mode="constant", value=0)
x = self.conv(x)
else:
x = torch.nn.functional.avg_pool2d(x, kernel_size=2, stride=2)
return x
class Encoder(nn.Module):
def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), scale_by_2=None, num_res_blocks,
attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels,
resolution, z_channels, double_z=False, **ignore_kwargs):
super().__init__()
if isinstance(resolution, int):
resolution = [resolution, resolution] # H, W
elif isinstance(resolution, (tuple, list)):
resolution = list(resolution)
else:
raise ValueError('Unknown type of resolution:', resolution)
attn_resolutions_ = []
for ar in attn_resolutions:
if isinstance(ar, (list, tuple)):
attn_resolutions_.append(list(ar))
else:
attn_resolutions_.append([ar, ar])
attn_resolutions = attn_resolutions_
self.ch = ch
self.temb_ch = 0
self.num_resolutions = len(ch_mult)
self.num_res_blocks = num_res_blocks
self.resolution = resolution
self.in_channels = in_channels
# downsampling
self.conv_in = torch.nn.Conv2d(in_channels,
self.ch,
kernel_size=3,
stride=1,
padding=1)
curr_res = resolution
in_ch_mult = (1,)+tuple(ch_mult)
self.down = nn.ModuleList()
for i_level in range(self.num_resolutions):
block = nn.ModuleList()
attn = nn.ModuleList()
block_in = ch*in_ch_mult[i_level]
block_out = ch*ch_mult[i_level]
for i_block in range(self.num_res_blocks):
block.append(ResnetBlock(in_channels=block_in,
out_channels=block_out,
temb_channels=self.temb_ch,
dropout=dropout))
block_in = block_out
if curr_res in attn_resolutions:
attn.append(AttnBlock(block_in))
down = nn.Module()
down.block = block
down.attn = attn
if scale_by_2 is None:
if i_level != self.num_resolutions-1:
down.downsample = Downsample(block_in, resamp_with_conv)
curr_res = [r // 2 for r in curr_res]
else:
if scale_by_2[i_level]:
down.downsample = Downsample(block_in, resamp_with_conv)
curr_res = [r // 2 for r in curr_res]
self.down.append(down)
# middle
self.mid = nn.Module()
self.mid.block_1 = ResnetBlock(in_channels=block_in,
out_channels=block_in,
temb_channels=self.temb_ch,
dropout=dropout)
self.mid.attn_1 = AttnBlock(block_in)
self.mid.block_2 = ResnetBlock(in_channels=block_in,
out_channels=block_in,
temb_channels=self.temb_ch,
dropout=dropout)
# end
self.norm_out = Normalize(block_in)
self.conv_out = torch.nn.Conv2d(block_in,
2*z_channels if double_z else z_channels,
kernel_size=3,
stride=1,
padding=1)
def forward(self, x):
#assert x.shape[2] == self.resolution[0] and x.shape[3] == self.resolution[1], "{}, {}, {}".format(x.shape[2], x.shape[3], self.resolution)
# timestep embedding
temb = None
# downsampling
hs = [self.conv_in(x)]
for i_level in range(self.num_resolutions):
for i_block in range(self.num_res_blocks):
h = self.down[i_level].block[i_block](hs[-1], temb)
if len(self.down[i_level].attn) > 0:
h = self.down[i_level].attn[i_block](h)
hs.append(h)
if getattr(self.down[i_level], 'downsample', None) is not None:
h = self.down[i_level].downsample(hs[-1])
if i_level != self.num_resolutions-1:
# hs.append(self.down[i_level].downsample(hs[-1]))
hs.append(h)
# middle
h = hs[-1]
h = self.mid.block_1(h, temb)
h = self.mid.attn_1(h)
h = self.mid.block_2(h, temb)
# end
h = self.norm_out(h)
h = nonlinearity(h)
h = self.conv_out(h)
return h
class Decoder(nn.Module):
def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), scale_by_2=None, num_res_blocks,
attn_resolutions, dropout=0.0, resamp_with_conv=True,
resolution, z_channels, **ignorekwargs):
super().__init__()
if isinstance(resolution, int):
resolution = [resolution, resolution] # H, W
elif isinstance(resolution, (tuple, list)):
resolution = list(resolution)
else:
raise ValueError('Unknown type of resolution:', resolution)
attn_resolutions_ = []
for ar in attn_resolutions:
if isinstance(ar, (list, tuple)):
attn_resolutions_.append(list(ar))
else:
attn_resolutions_.append([ar, ar])
attn_resolutions = attn_resolutions_
self.ch = ch
self.temb_ch = 0
self.num_resolutions = len(ch_mult)
self.num_res_blocks = num_res_blocks
self.resolution = resolution
self.requires_image = False
# compute in_ch_mult, block_in and curr_res at lowest res
in_ch_mult = (1,)+tuple(ch_mult)
block_in = ch*ch_mult[self.num_resolutions-1]
if scale_by_2 is None:
curr_res = [r // 2**(self.num_resolutions-1) for r in self.resolution]
else:
scale_factor = sum([int(s) for s in scale_by_2])
curr_res = [r // 2**scale_factor for r in self.resolution]
self.z_shape = (1, z_channels, curr_res[0], curr_res[1])
print("Working with z of shape {} = {} dimensions.".format(self.z_shape, np.prod(self.z_shape)))
# z to block_in
self.conv_in = torch.nn.Conv2d(z_channels,
block_in,
kernel_size=3,
stride=1,
padding=1)
# middle
self.mid = nn.Module()
self.mid.block_1 = ResnetBlock(in_channels=block_in,
out_channels=block_in,
temb_channels=self.temb_ch,
dropout=dropout)
self.mid.attn_1 = AttnBlock(block_in)
self.mid.block_2 = ResnetBlock(in_channels=block_in,
out_channels=block_in,
temb_channels=self.temb_ch,
dropout=dropout)
# upsampling
self.up = nn.ModuleList()
for i_level in reversed(range(self.num_resolutions)):
block = nn.ModuleList()
attn = nn.ModuleList()
block_out = ch*ch_mult[i_level]
for i_block in range(self.num_res_blocks+1):
block.append(ResnetBlock(in_channels=block_in,
out_channels=block_out,
temb_channels=self.temb_ch,
dropout=dropout))
block_in = block_out
if curr_res in attn_resolutions:
attn.append(AttnBlock(block_in))
up = nn.Module()
up.block = block
up.attn = attn
if scale_by_2 is None:
if i_level != 0:
up.upsample = Upsample(block_in, resamp_with_conv)
curr_res = [r * 2 for r in curr_res]
else:
if scale_by_2[i_level]:
up.upsample = Upsample(block_in, resamp_with_conv)
curr_res = [r * 2 for r in curr_res]
self.up.insert(0, up) # prepend to get consistent order
# end
self.norm_out = Normalize(block_in)
self.conv_out = torch.nn.Conv2d(block_in,
out_ch,
kernel_size=3,
stride=1,
padding=1)
def forward(self, z, **kwargs):
#assert z.shape[1:] == self.z_shape[1:]
self.last_z_shape = z.shape
# timestep embedding
temb = None
# z to block_in
h = self.conv_in(z)
# middle
h = self.mid.block_1(h, temb)
h = self.mid.attn_1(h)
h = self.mid.block_2(h, temb)
# upsampling
for i_level in reversed(range(self.num_resolutions)):
for i_block in range(self.num_res_blocks+1):
h = self.up[i_level].block[i_block](h, temb)
if len(self.up[i_level].attn) > 0:
h = self.up[i_level].attn[i_block](h)
# if i_level != 0:
if getattr(self.up[i_level], 'upsample', None) is not None:
h = self.up[i_level].upsample(h)
h = self.norm_out(h)
h = nonlinearity(h)
h = self.conv_out(h)
return h
class PatchVQGAN(BaseCodec):
def __init__(self,
*,
encoder_config,
decoder_config,
lossconfig=None,
n_embed,
embed_dim,
ignore_keys=[],
data_info={'key': 'image'},
quantizer_type='VQ',
quantizer_dis_type='euclidean',
decay = 0.99,
trainable=False,
ckpt_path=None,
token_shape=None
):
super().__init__()
self.encoder = instantiate_from_config(encoder_config) # Encoder(**encoder_config)
self.decoder = instantiate_from_config(decoder_config) # Decoder(**decoder_config)
if quantizer_type == 'EMAVQ':
self.quantize = EMAVectorQuantizer(n_embed, embed_dim, beta=0.25, decay = decay, distance_type=quantizer_dis_type)
print('using EMA vector Quantizer')
elif quantizer_type == 'PQEMAVQ':
self.quantize = PQEMAVectorQuantizer(n_embed, embed_dim, beta=0.25,decay = decay, distance_type=quantizer_dis_type)
print('using PQ EMA vector Quantizer')
elif quantizer_type == 'VQ':
self.quantize = VectorQuantizer(n_embed, embed_dim, beta=0.25)
else:
raise NotImplementedError
# import pdb; pdb.set_trace()
self.quant_conv = torch.nn.Conv2d(encoder_config['params']["z_channels"], embed_dim, 1)
self.post_quant_conv = torch.nn.Conv2d(embed_dim, decoder_config['params']["z_channels"], 1)
self.data_info = data_info
if lossconfig is not None and trainable:
self.loss = instantiate_from_config(lossconfig)
else:
self.loss = None
if ckpt_path is not None:
self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
self.trainable = trainable
self._set_trainable()
self.token_shape = token_shape
def init_from_ckpt(self, path, ignore_keys=list()):
sd = torch.load(path, map_location="cpu")
if 'model' in sd:
sd = sd['model']
else:
sd = sd["state_dict"]
keys = list(sd.keys())
for k in keys:
for ik in ignore_keys:
if k.startswith(ik):
print("VQGAN: Deleting key {} from state_dict.".format(k))
del sd[k]
self.load_state_dict(sd, strict=False)
print(f"VQGAN: Restored from {path}")
@property
def device(self):
return self.quant_conv.weight.device
def pre_process(self, data):
data = data.to(self.device)
data = data / 127.5 - 1.0
return data
def multi_pixels_with_mask(self, data, mask):
if data.max() > 1:
raise ValueError('The data need to be preprocessed!')
mask = mask.to(self.device)
data = data * mask
data[~mask.repeat(1,3,1,1)] = -1.0
return data
def post_process(self, data):
data = (data + 1.0) * 127.5
data = torch.clamp(data, min=0.0, max=255.0)
return data
def get_number_of_tokens(self):
return self.quantize.n_e
def get_tokens(self, data, mask=None, return_token_index=False, **kwargs):
data = self.pre_process(data)
x = self.encoder(data)
x = self.quant_conv(x)
idx = self.quantize(x)['index']
if self.token_shape is None:
self.token_shape = idx.shape[1:3]
if self.decoder.requires_image:
self.mask_im_tmp = self.multi_pixels_with_mask(data, mask)
output = {}
output['token'] = idx.view(idx.shape[0], -1)
# import pdb; pdb.set_trace()
if mask is not None: # mask should be B x 1 x H x W
# downsampling
# mask = F.interpolate(mask.float(), size=idx_mask.shape[-2:]).to(torch.bool)
token_type = get_token_type(mask, self.token_shape) # B x 1 x H x W
mask = token_type == 1
output = {
'target': idx.view(idx.shape[0], -1).clone(),
'mask': mask.view(mask.shape[0], -1),
'token': idx.view(idx.shape[0], -1),
'token_type': token_type.view(token_type.shape[0], -1),
}
else:
output = {
'token': idx.view(idx.shape[0], -1)
}
# get token index
# used for computing token frequency
if return_token_index:
token_index = output['token'] #.view(-1)
output['token_index'] = token_index
return output
def decode(self, token):
assert self.token_shape is not None
# import pdb; pdb.set_trace()
bhw = (token.shape[0], self.token_shape[0], self.token_shape[1])
quant = self.quantize.get_codebook_entry(token.view(-1), shape=bhw)
quant = self.post_quant_conv(quant)
if self.decoder.requires_image:
rec = self.decoder(quant, self.mask_im_tmp)
self.mask_im_tmp = None
else:
rec = self.decoder(quant)
rec = self.post_process(rec)
return rec
def get_rec_loss(self, input, rec):
if input.max() > 1:
input = self.pre_process(input)
if rec.max() > 1:
rec = self.pre_process(rec)
rec_loss = F.mse_loss(rec, input)
return rec_loss
@torch.no_grad()
def sample(self, batch):
data = self.pre_process(batch[self.data_info['key']])
x = self.encoder(data)
x = self.quant_conv(x)
quant = self.quantize(x)['quantize']
quant = self.post_quant_conv(quant)
if self.decoder.requires_image:
mask_im = self.multi_pixels_with_mask(data, batch['mask'])
rec = self.decoder(quant, mask_im)
else:
rec = self.decoder(quant)
rec = self.post_process(rec)
out = {'input': batch[self.data_info['key']], 'reconstruction': rec}
if self.decoder.requires_image:
out['mask_input'] = self.post_process(mask_im)
out['mask'] = batch['mask'] * 255
# import pdb; pdb.set_trace()
return out
def get_last_layer(self):
if isinstance(self.decoder, Decoder):
return self.decoder.conv_out.weight
elif isinstance(self.decoder, PatchDecoder):
return self.decoder.post_layer.weight
elif isinstance(self.decoder, Patch8x8Decoder):
return self.decoder.post_layer.weight
else:
return self.decoder.patch_de_embed.proj.weight
def parameters(self, recurse=True, name=None):
if name is None or name == 'none':
return super().parameters(recurse=recurse)
else:
if name == 'generator':
params = list(self.encoder.parameters())+ \
list(self.decoder.parameters())+\
list(self.quantize.parameters())+\
list(self.quant_conv.parameters())+\
list(self.post_quant_conv.parameters())
elif name == 'discriminator':
params = self.loss.discriminator.parameters()
else:
raise ValueError("Unknown type of name {}".format(name))
return params
def forward(self, batch, name='none', return_loss=True, step=0, **kwargs):
if name == 'generator':
input = self.pre_process(batch[self.data_info['key']])
x = self.encoder(input)
x = self.quant_conv(x)
quant_out = self.quantize(x)
quant = quant_out['quantize']
emb_loss = quant_out['quantize_loss']
# recconstruction
quant = self.post_quant_conv(quant)
if self.decoder.requires_image:
rec = self.decoder(quant, self.multi_pixels_with_mask(input, batch['mask']))
else:
rec = self.decoder(quant)
# save some tensors for
self.input_tmp = input
self.rec_tmp = rec
if isinstance(self.loss, VQLPIPSWithDiscriminator):
output = self.loss(codebook_loss=emb_loss,
inputs=input,
reconstructions=rec,
optimizer_name=name,
global_step=step,
last_layer=self.get_last_layer())
else:
raise NotImplementedError('{}'.format(type(self.loss)))
elif name == 'discriminator':
if isinstance(self.loss, VQLPIPSWithDiscriminator):
output = self.loss(codebook_loss=None,
inputs=self.input_tmp,
reconstructions=self.rec_tmp,
optimizer_name=name,
global_step=step,
last_layer=self.get_last_layer())
else:
raise NotImplementedError('{}'.format(type(self.loss)))
else:
raise NotImplementedError('{}'.format(name))
return output
| 35,439 | 38.116998 | 147 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/codecs/image_codec/ema_vqvae.py | import torch
import torch.nn as nn
from omegaconf import OmegaConf
import sys
sys.path.append("..")
# sys.path.append("../image_synthesis")
import os
import torchvision.transforms.functional as TF
import PIL
from image_synthesis.modeling.codecs.base_codec import BaseCodec
from einops import rearrange
import math
import yaml
from image_synthesis.utils.misc import instantiate_from_config
class Encoder(nn.Module):
def __init__(self, encoder, quant_conv, quantize):
super().__init__()
self.encoder = encoder
self.quant_conv = quant_conv
self.quantize = quantize
@torch.no_grad()
def forward(self, x):
x = 2*x - 1
h = self.encoder(x)
h = self.quant_conv(h)
# quant, _, [_, _, indices] = self.quantize(h)
# return indices.view(x.shape[0], -1)
indices = self.quantize.only_get_indices(h)
return indices.view(x.shape[0], -1)
class Decoder(nn.Module):
def __init__(self, decoder, post_quant_conv, quantize, w=16, h=16):
super().__init__()
self.decoder = decoder
self.post_quant_conv = post_quant_conv
self.quantize = quantize
self.w = w
self.h = h
@torch.no_grad()
def forward(self, indices):
z = self.quantize.get_codebook_entry(indices.view(-1), shape=(indices.shape[0], self.h, self.w))
quant = self.post_quant_conv(z)
dec = self.decoder(quant)
x = torch.clamp(dec, -1., 1.)
x = (x + 1.)/2.
return x
class PatchVQVAE(BaseCodec):
def __init__(
self,
trainable=False,
token_shape=[16,16],
):
super().__init__()
config_path = "OUTPUT/pretrained_model/taming_dvae/config.yaml"
ckpt_path="OUTPUT/pretrained_model/taming_dvae/ithq_vqvae.pth"
model = self.LoadModel(config_path, ckpt_path)
self.enc = Encoder(model.encoder, model.quant_conv, model.quantize)
self.dec = Decoder(model.decoder, model.post_quant_conv, model.quantize, token_shape[0], token_shape[1])
self.num_tokens = 4096
self.trainable = trainable
self.token_shape = token_shape
self._set_trainable()
def LoadModel(self, config_path, ckpt_path):
with open(config_path) as f:
config = yaml.full_load(f)
model = instantiate_from_config(config['model'])
sd = torch.load(ckpt_path, map_location="cpu")["model"]
model.load_state_dict(sd, strict=False)
return model
def half(self): # not sure if it's right
"""
overwrite this function
"""
from dall_e.utils import Conv2d
for n, m in self.named_modules():
if isinstance(m, Conv2d) and m.use_float16:
print(n)
m._apply(lambda t: t.half() if t.is_floating_point() else t)
return self
@property
def device(self):
# import pdb; pdb.set_trace()
return self.enc.quant_conv.weight.device
def preprocess(self, imgs):
"""
imgs: B x C x H x W, in the range 0-255
"""
imgs = imgs.div(255) # map to 0 - 1
return imgs
# return map_pixels(imgs)
def postprocess(self, imgs):
"""
imgs: B x C x H x W, in the range 0-1
"""
imgs = imgs * 255
return imgs
def get_tokens(self, imgs, **kwargs):
imgs = self.preprocess(imgs)
code = self.enc(imgs)
output = {'token': code}
# output = {'token': rearrange(code, 'b h w -> b (h w)')}
return output
def decode(self, img_seq):
b, n = img_seq.shape
# if self.token_shape is not None:
# img_seq = img_seq.view(b, self.token_shape[0], self.token_shape[1])
# else:
# img_seq = rearrange(img_seq, 'b (h w) -> b h w', h = int(sqrt(n)))
img_seq = rearrange(img_seq, 'b (h w) -> b h w', h = int(math.sqrt(n)))
x_rec = self.dec(img_seq)
x_rec = self.postprocess(x_rec)
return x_rec
| 4,083 | 29.706767 | 112 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/codecs/text_codec/tokenize.py | import torch
import torch.nn as nn
from image_synthesis.modeling.modules.clip.clip import tokenize
from image_synthesis.modeling.codecs.base_codec import BaseCodec
from image_synthesis.utils.misc import instantiate_from_config
class Tokenize(BaseCodec):
def __init__(self, context_length:int = 256,
add_start_and_end:bool = False,
just_token = False,
with_mask:bool = True,
pad_value:int = 0,
clip_embedding = False,
condition_emb_config = None,
tokenizer_config={
'target': 'image_synthesis.modeling.modules.clip.simple_tokenizer.SimpleTokenizer',
'params':{
'end_idx': 49152 # 16384 fo DALL-E
},
},
):
"""
This is a wrapper class for tokenize of texts.
For CLIP and DALLE-pytorch tokenize, the default
arguments are different:
CLIP based:
context_length: 77
add_start_and_end: True
DALLE-pytorch based:
context_length: 256
add_start_and_end: False
"""
super().__init__()
self.context_length = context_length
self.add_start_and_end = add_start_and_end
self.with_mask = with_mask
self.pad_value = pad_value
self.just_token = just_token
self.trainable = False
self.condition_emb = None
self.clip_embedding = clip_embedding
if self.clip_embedding == True:
assert condition_emb_config != None
self.condition_emb = instantiate_from_config(condition_emb_config)
self.tokenizer = instantiate_from_config(tokenizer_config)
def __repr__(self):
rep = "Tokenize for text\n\tcontent_length: {}\n\tadd_start_and_end: {}\n\twith_mask: {}"\
.format(self.context_length, self.add_start_and_end, self.with_mask)
return rep
def check_length(self, token):
return len(token) <= self.context_length
def get_tokens(self, text, **kwargs):
text_token = tokenize(text, context_length=self.context_length,
add_start_and_end=self.add_start_and_end,
with_mask=self.with_mask, pad_value=self.pad_value,
tokenizer=self.tokenizer,
just_token=self.just_token)
if self.clip_embedding == False:
return text_token
else:
if self.condition_emb.additional_last_embedding == True:
with torch.no_grad():
cond_emb, last_embedding = self.condition_emb(text_token['token'].cuda())
text_token['embed_token'] = cond_emb.detach()
text_token['last_embed'] = last_embedding
else:
with torch.no_grad():
cond_emb = self.condition_emb(text_token['token'].cuda())
text_token['embed_token'] = cond_emb.detach()
return text_token
| 3,124 | 36.202381 | 104 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/models/conditional_dalle.py | # ------------------------------------------
# VQ-Diffusion
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
# written By Shuyang Gu
# ------------------------------------------
import torch
import math
from torch import nn
from image_synthesis.utils.misc import instantiate_from_config
import time
import numpy as np
from PIL import Image
import os
from torch.cuda.amp import autocast
class C_DALLE(nn.Module):
def __init__(
self,
*,
content_info={'key': 'image'},
condition_info={'key': 'label'},
guidance_scale=1.0,
learnable_cf=False,
content_codec_config,
diffusion_config
):
super().__init__()
self.content_info = content_info
self.condition_info = condition_info
self.guidance_scale = guidance_scale
self.content_codec = instantiate_from_config(content_codec_config)
self.transformer = instantiate_from_config(diffusion_config)
self.truncation_forward = False
def parameters(self, recurse=True, name=None):
# return super().parameters(recurse=True)
if name is None or name == 'none':
return super().parameters(recurse=recurse)
else:
names = name.split('+')
params = []
for n in names:
try: # the parameters() method is not overwritten for some classes
params += getattr(self, name).parameters(recurse=recurse, name=name)
except:
params += getattr(self, name).parameters(recurse=recurse)
return params
@property
def device(self):
return self.transformer.device
def get_ema_model(self):
return self.transformer
@torch.no_grad()
def prepare_condition(self, batch):
cond_key = self.condition_info['key']
cond = batch[cond_key]
if torch.is_tensor(cond):
cond = cond.to(self.device)
cond_ = {}
cond_['condition_token'] = cond
return cond_
@autocast(enabled=False)
@torch.no_grad()
def prepare_content(self, batch, with_mask=False):
cont_key = self.content_info['key']
cont = batch[cont_key]
if torch.is_tensor(cont):
cont = cont.to(self.device)
if not with_mask:
cont = self.content_codec.get_tokens(cont)
else:
mask = batch['mask'.format(cont_key)]
cont = self.content_codec.get_tokens(cont, mask, enc_with_mask=False)
cont_ = {}
for k, v in cont.items():
v = v.to(self.device) if torch.is_tensor(v) else v
cont_['content_' + k] = v
return cont_
@torch.no_grad()
def prepare_input(self, batch):
input = self.prepare_condition(batch)
input.update(self.prepare_content(batch))
return input
def predict_start_with_truncation(self, func, sample_type):
if sample_type[-1] == 'p':
truncation_k = int(sample_type[:-1].replace('top', ''))
content_codec = self.content_codec
save_path = self.this_save_path
def wrapper(*args, **kwards):
out = func(*args, **kwards)
val, ind = out.topk(k = truncation_k, dim=1)
probs = torch.full_like(out, -70)
probs.scatter_(1, ind, val)
return probs
return wrapper
elif sample_type[-1] == 'r':
truncation_r = float(sample_type[:-1].replace('top', ''))
def wrapper(*args, **kwards):
out = func(*args, **kwards)
temp, indices = torch.sort(out, 1, descending=True)
temp1 = torch.exp(temp)
temp2 = temp1.cumsum(dim=1)
temp3 = temp2 < truncation_r
new_temp = torch.full_like(temp3[:,0:1,:], True)
temp6 = torch.cat((new_temp, temp3), dim=1)
temp3 = temp6[:,:-1,:]
temp4 = temp3.gather(1, indices.argsort(1))
temp5 = temp4.float()*out+(1-temp4.float())*(-70)
probs = temp5
return probs
return wrapper
else:
print("wrong sample type")
@torch.no_grad()
def generate_content(
self,
*,
batch,
condition=None,
filter_ratio = 0.5,
temperature = 1.0,
content_ratio = 0.0,
replicate=1,
return_att_weight=False,
sample_type="normal",
):
self.eval()
if type(batch['label']) == list:
batch['label']=torch.tensor(batch['label'])
if condition is None:
condition = self.prepare_condition(batch=batch)
else:
condition = self.prepare_condition(batch=None, condition=condition)
# content = None
if replicate != 1:
for k in condition.keys():
if condition[k] is not None:
condition[k] = torch.cat([condition[k] for _ in range(replicate)], dim=0)
content_token = None
guidance_scale = self.guidance_scale
cf_cond_emb = torch.ones(len(batch['label']) * replicate).to(self.device) * 1000
def cf_predict_start(log_x_t, cond_emb, t):
log_x_recon = self.transformer.predict_start(log_x_t, cond_emb, t)[:, :-1]
if abs(guidance_scale - 1) < 1e-3:
return torch.cat((log_x_recon, self.transformer.zero_vector), dim=1)
cf_log_x_recon = self.transformer.predict_start(log_x_t, cf_cond_emb.type_as(cond_emb), t)[:, :-1]
log_new_x_recon = cf_log_x_recon + guidance_scale * (log_x_recon - cf_log_x_recon)
log_new_x_recon -= torch.logsumexp(log_new_x_recon, dim=1, keepdim=True)
log_new_x_recon = log_new_x_recon.clamp(-70, 0)
log_pred = torch.cat((log_new_x_recon, self.transformer.zero_vector), dim=1)
return log_pred
if sample_type.split(',')[0][:3] == "top" and self.truncation_forward == False:
self.transformer.cf_predict_start = self.predict_start_with_truncation(cf_predict_start, sample_type.split(',')[0])
self.truncation_forward = True
trans_out = self.transformer.sample(condition_token=condition['condition_token'],
condition_mask=condition.get('condition_mask', None),
condition_embed=condition.get('condition_embed_token', None),
content_token=content_token,
filter_ratio=filter_ratio,
temperature=temperature,
return_att_weight=return_att_weight,
return_logits=False,
print_log=False,
sample_type=sample_type)
content = self.content_codec.decode(trans_out['content_token']) #(8,1024)->(8,3,256,256)
self.train()
out = {
'content': content
}
return out
@torch.no_grad()
def reconstruct(
self,
input
):
if torch.is_tensor(input):
input = input.to(self.device)
cont = self.content_codec.get_tokens(input)
cont_ = {}
for k, v in cont.items():
v = v.to(self.device) if torch.is_tensor(v) else v
cont_['content_' + k] = v
rec = self.content_codec.decode(cont_['content_token'])
return rec
@torch.no_grad()
def sample(
self,
batch,
clip = None,
temperature = 1.,
return_rec = True,
filter_ratio = [0, 0.5, 1.0],
content_ratio = [1], # the ratio to keep the encoded content tokens
return_att_weight=False,
return_logits=False,
sample_type="normal",
**kwargs,
):
self.eval()
condition = self.prepare_condition(batch)
content = self.prepare_content(batch)
content_samples = {'input_image': batch[self.content_info['key']]}
if return_rec:
content_samples['reconstruction_image'] = self.content_codec.decode(content['content_token'])
# import pdb; pdb.set_trace()
for fr in filter_ratio:
for cr in content_ratio:
num_content_tokens = int((content['content_token'].shape[1] * cr))
if num_content_tokens < 0:
continue
else:
content_token = content['content_token'][:, :num_content_tokens]
if sample_type == 'debug':
trans_out = self.transformer.sample_debug(condition_token=condition['condition_token'],
condition_mask=condition.get('condition_mask', None),
condition_embed=condition.get('condition_embed_token', None),
content_token=content_token,
filter_ratio=fr,
temperature=temperature,
return_att_weight=return_att_weight,
return_logits=return_logits,
content_logits=content.get('content_logits', None),
sample_type=sample_type,
**kwargs)
else:
trans_out = self.transformer.sample(condition_token=condition['condition_token'],
condition_mask=condition.get('condition_mask', None),
condition_embed=condition.get('condition_embed_token', None),
content_token=content_token,
filter_ratio=fr,
temperature=temperature,
return_att_weight=return_att_weight,
return_logits=return_logits,
content_logits=content.get('content_logits', None),
sample_type=sample_type,
**kwargs)
content_samples['cond1_cont{}_fr{}_image'.format(cr, fr)] = self.content_codec.decode(trans_out['content_token'])
if return_att_weight:
content_samples['cond1_cont{}_fr{}_image_condition_attention'.format(cr, fr)] = trans_out['condition_attention'] # B x Lt x Ld
content_att = trans_out['content_attention']
shape = *content_att.shape[:-1], self.content.token_shape[0], self.content.token_shape[1]
content_samples['cond1_cont{}_fr{}_image_content_attention'.format(cr, fr)] = content_att.view(*shape) # B x Lt x Lt -> B x Lt x H x W
if return_logits:
content_samples['logits'] = trans_out['logits']
self.train()
output = {'condition': batch[self.condition_info['key']]}
output.update(content_samples)
return output
def forward(
self,
batch,
name='none',
**kwargs
):
input = self.prepare_input(batch)
output = self.transformer(input, **kwargs)
return output
| 11,968 | 40.559028 | 154 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/models/unconditional_dalle.py | # ------------------------------------------
# VQ-Diffusion
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
# written By Shuyang Gu
# ------------------------------------------
import torch
import math
from torch import nn
from image_synthesis.utils.misc import instantiate_from_config
import time
import numpy as np
from PIL import Image
import os
from torch.cuda.amp import autocast
class UC_DALLE(nn.Module):
def __init__(
self,
*,
content_info={'key': 'image'},
content_codec_config,
diffusion_config
):
super().__init__()
self.content_info = content_info
self.content_codec = instantiate_from_config(content_codec_config)
self.transformer = instantiate_from_config(diffusion_config)
self.truncation_forward = False
def parameters(self, recurse=True, name=None):
if name is None or name == 'none':
return super().parameters(recurse=recurse)
else:
names = name.split('+')
params = []
for n in names:
try: # the parameters() method is not overwritten for some classes
params += getattr(self, name).parameters(recurse=recurse, name=name)
except:
params += getattr(self, name).parameters(recurse=recurse)
return params
@property
def device(self):
return self.transformer.device
def get_ema_model(self):
return self.transformer
@autocast(enabled=False)
@torch.no_grad()
def prepare_content(self, batch, with_mask=False):
cont_key = self.content_info['key']
cont = batch[cont_key]
if torch.is_tensor(cont):
cont = cont.to(self.device)
if not with_mask:
cont = self.content_codec.get_tokens(cont)
else:
mask = batch['mask'.format(cont_key)]
cont = self.content_codec.get_tokens(cont, mask, enc_with_mask=False)
cont_ = {}
for k, v in cont.items():
v = v.to(self.device) if torch.is_tensor(v) else v
cont_['content_' + k] = v
return cont_
@torch.no_grad()
def prepare_input(self, batch):
input = self.prepare_content(batch)
return input
def predict_start_with_truncation(self, func, sample_type):
if sample_type[-1] == 'p':
truncation_k = int(sample_type[:-1].replace('top', ''))
content_codec = self.content_codec
save_path = self.this_save_path
def wrapper(*args, **kwards):
out = func(*args, **kwards)
val, ind = out.topk(k = truncation_k, dim=1)
probs = torch.full_like(out, -70)
probs.scatter_(1, ind, val)
return probs
return wrapper
elif sample_type[-1] == 'r':
truncation_r = float(sample_type[:-1].replace('top', ''))
def wrapper(*args, **kwards):
out = func(*args, **kwards)
temp, indices = torch.sort(out, 1, descending=True)
temp1 = torch.exp(temp)
temp2 = temp1.cumsum(dim=1)
temp3 = temp2 < truncation_r
new_temp = torch.full_like(temp3[:,0:1,:], True)
temp6 = torch.cat((new_temp, temp3), dim=1)
temp3 = temp6[:,:-1,:]
temp4 = temp3.gather(1, indices.argsort(1))
temp5 = temp4.float()*out+(1-temp4.float())*(-70)
probs = temp5
return probs
return wrapper
else:
print("wrong sample type")
@torch.no_grad()
def generate_content(
self,
*,
batch,
filter_ratio = 0.5,
temperature = 1.0,
content_ratio = 0.0,
replicate=1,
return_att_weight=False,
sample_type="normal",
):
self.eval()
content_token = None
if sample_type.split(',')[0][:3] == "top" and self.truncation_forward == False:
self.transformer.predict_start = self.predict_start_with_truncation(self.transformer.predict_start, sample_type.split(',')[0])
self.truncation_forward = True
trans_out = self.transformer.sample(condition_token=None,
condition_mask=None,
condition_embed=None,
content_token=content_token,
filter_ratio=filter_ratio,
temperature=temperature,
return_att_weight=return_att_weight,
return_logits=False,
print_log=False,
sample_type=sample_type,
batch_size=replicate)
content = self.content_codec.decode(trans_out['content_token']) #(8,1024)->(8,3,256,256)
self.train()
out = {
'content': content
}
return out
@torch.no_grad()
def reconstruct(
self,
input
):
if torch.is_tensor(input):
input = input.to(self.device)
cont = self.content_codec.get_tokens(input)
cont_ = {}
for k, v in cont.items():
v = v.to(self.device) if torch.is_tensor(v) else v
cont_['content_' + k] = v
rec = self.content_codec.decode(cont_['content_token'])
return rec
@torch.no_grad()
def sample(
self,
batch,
clip = None,
temperature = 1.,
return_rec = True,
filter_ratio = [0],
content_ratio = [1], # the ratio to keep the encoded content tokens
return_att_weight=False,
return_logits=False,
sample_type="normal",
**kwargs,
):
self.eval()
content = self.prepare_content(batch)
content_samples = {'input_image': batch[self.content_info['key']]}
if return_rec:
content_samples['reconstruction_image'] = self.content_codec.decode(content['content_token'])
# import pdb; pdb.set_trace()
for fr in filter_ratio:
for cr in content_ratio:
num_content_tokens = int((content['content_token'].shape[1] * cr))
if num_content_tokens < 0:
continue
else:
content_token = content['content_token'][:, :num_content_tokens]
trans_out = self.transformer.sample(condition_token=None,
condition_mask=None,
condition_embed=None,
content_token=content_token,
filter_ratio=fr,
temperature=temperature,
return_att_weight=return_att_weight,
return_logits=return_logits,
content_logits=content.get('content_logits', None),
sample_type=sample_type,
batch_size=batch[self.content_info['key']].shape[0],
**kwargs)
content_samples['cond1_cont{}_fr{}_image'.format(cr, fr)] = self.content_codec.decode(trans_out['content_token'])
if return_logits:
content_samples['logits'] = trans_out['logits']
self.train()
output = {}
output.update(content_samples)
return output
def forward(
self,
batch,
name='none',
**kwargs
):
input = self.prepare_input(batch)
output = self.transformer(input, **kwargs)
return output
| 8,216 | 35.52 | 138 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/models/dalle.py | # ------------------------------------------
# VQ-Diffusion
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
# written By Shuyang Gu
# ------------------------------------------
import torch
import math
from torch import nn
from image_synthesis.utils.misc import instantiate_from_config
import time
import numpy as np
from PIL import Image
import os
from torch.cuda.amp import autocast
class DALLE(nn.Module):
def __init__(
self,
*,
content_info={'key': 'image'},
condition_info={'key': 'text'},
learnable_cf=False,
content_codec_config,
condition_codec_config,
diffusion_config
):
super().__init__()
self.content_info = content_info
self.condition_info = condition_info
self.guidance_scale = 1.0
self.learnable_cf = learnable_cf
self.content_codec = instantiate_from_config(content_codec_config)
self.condition_codec = instantiate_from_config(condition_codec_config)
self.transformer = instantiate_from_config(diffusion_config)
self.truncation_forward = False
def parameters(self, recurse=True, name=None):
if name is None or name == 'none':
return super().parameters(recurse=recurse)
else:
names = name.split('+')
params = []
for n in names:
try: # the parameters() method is not overwritten for some classes
params += getattr(self, name).parameters(recurse=recurse, name=name)
except:
params += getattr(self, name).parameters(recurse=recurse)
return params
@property
def device(self):
return self.transformer.device
def get_ema_model(self):
return self.transformer
@torch.no_grad()
def prepare_condition(self, batch, condition=None):
cond_key = self.condition_info['key']
cond = batch[cond_key] if condition is None else condition
if torch.is_tensor(cond):
cond = cond.to(self.device)
cond = self.condition_codec.get_tokens(cond)
cond_ = {}
for k, v in cond.items():
v = v.to(self.device) if torch.is_tensor(v) else v
cond_['condition_' + k] = v
return cond_
@autocast(enabled=False)
@torch.no_grad()
def prepare_content(self, batch, with_mask=False):
cont_key = self.content_info['key']
cont = batch[cont_key]
if torch.is_tensor(cont):
cont = cont.to(self.device)
if not with_mask:
cont = self.content_codec.get_tokens(cont)
else:
mask = batch['mask'.format(cont_key)]
cont = self.content_codec.get_tokens(cont, mask, enc_with_mask=False)
cont_ = {}
for k, v in cont.items():
v = v.to(self.device) if torch.is_tensor(v) else v
cont_['content_' + k] = v
return cont_
@autocast(enabled=False)
@torch.no_grad()
def prepare_input(self, batch):
input = self.prepare_condition(batch)
input.update(self.prepare_content(batch))
return input
def p_sample_with_truncation(self, func, sample_type):
truncation_rate = float(sample_type.replace('q', ''))
def wrapper(*args, **kwards):
out = func(*args, **kwards)
import random
if random.random() < truncation_rate:
out = func(out, args[1], args[2], **kwards)
return out
return wrapper
def predict_start_with_truncation(self, func, sample_type):
if sample_type[-1] == 'p':
truncation_k = int(sample_type[:-1].replace('top', ''))
content_codec = self.content_codec
save_path = self.this_save_path
def wrapper(*args, **kwards):
out = func(*args, **kwards)
val, ind = out.topk(k = truncation_k, dim=1)
probs = torch.full_like(out, -70)
probs.scatter_(1, ind, val)
return probs
return wrapper
elif sample_type[-1] == 'r':
truncation_r = float(sample_type[:-1].replace('top', ''))
def wrapper(*args, **kwards):
out = func(*args, **kwards)
# notice for different batches, out are same, we do it on out[0]
temp, indices = torch.sort(out, 1, descending=True)
temp1 = torch.exp(temp)
temp2 = temp1.cumsum(dim=1)
temp3 = temp2 < truncation_r
new_temp = torch.full_like(temp3[:,0:1,:], True)
temp6 = torch.cat((new_temp, temp3), dim=1)
temp3 = temp6[:,:-1,:]
temp4 = temp3.gather(1, indices.argsort(1))
temp5 = temp4.float()*out+(1-temp4.float())*(-70)
probs = temp5
return probs
return wrapper
else:
print("wrong sample type")
@torch.no_grad()
def generate_content(
self,
*,
batch,
condition=None,
filter_ratio = 0.5,
temperature = 1.0,
content_ratio = 0.0,
replicate=1,
return_att_weight=False,
sample_type="top0.85r",
):
self.eval()
if condition is None:
condition = self.prepare_condition(batch=batch)
else:
condition = self.prepare_condition(batch=None, condition=condition)
batch_size = len(batch['text']) * replicate
if self.learnable_cf:
cf_cond_emb = self.transformer.empty_text_embed.unsqueeze(0).repeat(batch_size, 1, 1)
else:
batch['text'] = [''] * batch_size
cf_condition = self.prepare_condition(batch=batch)
cf_cond_emb = self.transformer.condition_emb(cf_condition['condition_token']).float()
def cf_predict_start(log_x_t, cond_emb, t):
log_x_recon = self.transformer.predict_start(log_x_t, cond_emb, t)[:, :-1]
if abs(self.guidance_scale - 1) < 1e-3:
return torch.cat((log_x_recon, self.transformer.zero_vector), dim=1)
cf_log_x_recon = self.transformer.predict_start(log_x_t, cf_cond_emb.type_as(cond_emb), t)[:, :-1]
log_new_x_recon = cf_log_x_recon + self.guidance_scale * (log_x_recon - cf_log_x_recon)
log_new_x_recon -= torch.logsumexp(log_new_x_recon, dim=1, keepdim=True)
log_new_x_recon = log_new_x_recon.clamp(-70, 0)
log_pred = torch.cat((log_new_x_recon, self.transformer.zero_vector), dim=1)
return log_pred
if replicate != 1:
for k in condition.keys():
if condition[k] is not None:
condition[k] = torch.cat([condition[k] for _ in range(replicate)], dim=0)
content_token = None
if len(sample_type.split(',')) > 1:
if sample_type.split(',')[1][:1]=='q':
self.transformer.p_sample = self.p_sample_with_truncation(self.transformer.p_sample, sample_type.split(',')[1])
if sample_type.split(',')[0][:3] == "top" and self.truncation_forward == False:
self.transformer.cf_predict_start = self.predict_start_with_truncation(cf_predict_start, sample_type.split(',')[0])
self.truncation_forward = True
if len(sample_type.split(',')) == 2 and sample_type.split(',')[1][:4]=='time' and int(float(sample_type.split(',')[1][4:])) >= 2:
trans_out = self.transformer.sample_fast(condition_token=condition['condition_token'],
condition_mask=condition.get('condition_mask', None),
condition_embed=condition.get('condition_embed_token', None),
content_token=content_token,
filter_ratio=filter_ratio,
temperature=temperature,
return_att_weight=return_att_weight,
return_logits=False,
print_log=False,
sample_type=sample_type,
skip_step=int(float(sample_type.split(',')[1][4:])-1))
else:
if 'time' in sample_type and float(sample_type.split(',')[1][4:]) < 1:
self.transformer.prior_ps = int(1024 // self.transformer.num_timesteps * float(sample_type.split(',')[1][4:]))
if self.transformer.prior_rule == 0:
self.transformer.prior_rule = 1
self.transformer.update_n_sample()
trans_out = self.transformer.sample(condition_token=condition['condition_token'],
condition_mask=condition.get('condition_mask', None),
condition_embed=condition.get('condition_embed_token', None),
content_token=content_token,
filter_ratio=filter_ratio,
temperature=temperature,
return_att_weight=return_att_weight,
return_logits=False,
print_log=False,
sample_type=sample_type)
content = self.content_codec.decode(trans_out['content_token']) #(8,1024)->(8,3,256,256)
self.train()
out = {
'content': content
}
return out
@torch.no_grad()
def reconstruct(
self,
input
):
if torch.is_tensor(input):
input = input.to(self.device)
cont = self.content_codec.get_tokens(input)
cont_ = {}
for k, v in cont.items():
v = v.to(self.device) if torch.is_tensor(v) else v
cont_['content_' + k] = v
rec = self.content_codec.decode(cont_['content_token'])
return rec
@torch.no_grad()
def sample(
self,
batch,
clip = None,
temperature = 1.,
return_rec = True,
filter_ratio = [0, 0.5, 1.0],
content_ratio = [1], # the ratio to keep the encoded content tokens
return_att_weight=False,
return_logits=False,
sample_type="normal",
**kwargs,
):
self.eval()
condition = self.prepare_condition(batch)
content = self.prepare_content(batch)
content_samples = {'input_image': batch[self.content_info['key']]}
if return_rec:
content_samples['reconstruction_image'] = self.content_codec.decode(content['content_token'])
for fr in filter_ratio:
for cr in content_ratio:
num_content_tokens = int((content['content_token'].shape[1] * cr))
if num_content_tokens < 0:
continue
else:
content_token = content['content_token'][:, :num_content_tokens]
if sample_type == 'debug':
trans_out = self.transformer.sample_debug(condition_token=condition['condition_token'],
condition_mask=condition.get('condition_mask', None),
condition_embed=condition.get('condition_embed_token', None),
content_token=content_token,
filter_ratio=fr,
temperature=temperature,
return_att_weight=return_att_weight,
return_logits=return_logits,
content_logits=content.get('content_logits', None),
sample_type=sample_type,
**kwargs)
else:
trans_out = self.transformer.sample(condition_token=condition['condition_token'],
condition_mask=condition.get('condition_mask', None),
condition_embed=condition.get('condition_embed_token', None),
content_token=content_token,
filter_ratio=fr,
temperature=temperature,
return_att_weight=return_att_weight,
return_logits=return_logits,
content_logits=content.get('content_logits', None),
sample_type=sample_type,
**kwargs)
content_samples['cond1_cont{}_fr{}_image'.format(cr, fr)] = self.content_codec.decode(trans_out['content_token'])
if return_att_weight:
content_samples['cond1_cont{}_fr{}_image_condition_attention'.format(cr, fr)] = trans_out['condition_attention'] # B x Lt x Ld
content_att = trans_out['content_attention']
shape = *content_att.shape[:-1], self.content.token_shape[0], self.content.token_shape[1]
content_samples['cond1_cont{}_fr{}_image_content_attention'.format(cr, fr)] = content_att.view(*shape) # B x Lt x Lt -> B x Lt x H x W
if return_logits:
content_samples['logits'] = trans_out['logits']
self.train()
output = {'condition': batch[self.condition_info['key']]}
output.update(content_samples)
return output
def forward(
self,
batch,
name='none',
**kwargs
):
input = self.prepare_input(batch)
output = self.transformer(input, **kwargs)
return output
| 14,512 | 43.246951 | 154 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/embeddings/class_embedding.py | import torch
import torch.nn as nn
from .base_embedding import BaseEmbedding
class ClassEmbedding(BaseEmbedding):
def __init__(self,
num_embed=1000,
embed_dim=512,
identity=False,
trainable=True,
):
super().__init__()
self.identity = identity
self.trainable = trainable
self.num_embed = num_embed
self.embed_dim = embed_dim
if self.identity == False:
self.emb = nn.Embedding(self.num_embed, embed_dim)
self._set_trainable()
def forward(self, index, **kwargs):
"""
index: B x L, index
mask: B x L, bool type. The value of False indicating padded index
"""
if self.identity == True:
return index
else:
emb = self.emb(index).unsqueeze(1)
return emb
| 899 | 26.272727 | 74 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/embeddings/dalle_mask_image_embedding.py | import torch
import torch.nn as nn
from .base_embedding import BaseEmbedding
class DalleMaskImageEmbedding(BaseEmbedding):
def __init__(self,
num_embed=8192,
spatial_size=[32, 32], # height and with
embed_dim=3968,
trainable=True,
pos_emb_type='embedding'
):
super().__init__()
if isinstance(spatial_size, int):
spatial_size = [spatial_size, spatial_size]
self.spatial_size = spatial_size
self.num_embed = num_embed + 1
self.embed_dim = embed_dim
self.trainable = trainable
self.pos_emb_type = pos_emb_type
assert self.pos_emb_type in ['embedding', 'parameter']
self.emb = nn.Embedding(self.num_embed, embed_dim)
if self.pos_emb_type == 'embedding':
self.height_emb = nn.Embedding(self.spatial_size[0], embed_dim) # height
self.width_emb = nn.Embedding(self.spatial_size[1], embed_dim) # width
else:
self.height_emb = nn.Parameter(torch.zeros(1, self.spatial_size[0], embed_dim)) # height #32,1024
self.width_emb = nn.Parameter(torch.zeros(1, self.spatial_size[1], embed_dim)) # width #32,1024
self._set_trainable()
def forward(self, index, **kwargs):
assert index.dim() == 2 # B x L
try:
index[index < 0] = 0
emb = self.emb(index)
except:
raise RuntimeError('IndexError: index out of range in self, max index {}, num embed {}'.format(index.max(), self.num_embed))
# add col and row embedding
if emb.shape[1] > 0:
# if False:
if self.pos_emb_type == 'embedding':
height_emb = self.height_emb(torch.arange(self.spatial_size[0], device=index.device).view(1, self.spatial_size[0])).unsqueeze(2) # 1 x H x D -> 1 x H x 1 x D
width_emb = self.width_emb(torch.arange(self.spatial_size[1], device=index.device).view(1, self.spatial_size[1])).unsqueeze(1) # 1 x W x D -> 1 x 1 x W x D
else:
height_emb = self.height_emb.unsqueeze(2) # 1 x H x D -> 1 x H x 1 x D
width_emb = self.width_emb.unsqueeze(1) # 1 x W x D -> 1 x 1 x W x D
pos_emb = (height_emb + width_emb).view(1, self.spatial_size[0] * self.spatial_size[1], -1) # 1 x H x W x D -> 1 x L xD
emb = emb + pos_emb[:, :emb.shape[1], :]
return emb
| 2,507 | 42.241379 | 173 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/embeddings/base_embedding.py | import torch
from torch import nn
class BaseEmbedding(nn.Module):
def get_loss(self):
return None
def forward(self, **kwargs):
raise NotImplementedError
def train(self, mode=True):
self.training = mode
if self.trainable and mode:
super().train()
return self
def _set_trainable(self):
if not self.trainable:
for pn, p in self.named_parameters():
p.requires_grad = False
self.eval()
| 507 | 19.32 | 49 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/embeddings/clip_text_embedding.py | import torch
import torch.nn as nn
from image_synthesis.modeling.modules.clip import clip
from image_synthesis.modeling.modules.clip import model as clip_model
from .base_embedding import BaseEmbedding
class CLIPTextEmbedding(BaseEmbedding):
def __init__(self,
clip_name='ViT-B/32',
num_embed=49408,
normalize=True,
pick_last_embedding=True,
keep_seq_len_dim=False,
additional_last_embedding=False,
embed_dim=1024,
):
super().__init__()
self.num_embed = num_embed
self.clip_name = clip_name
self.normalize = normalize
self.pick_last_embedding = pick_last_embedding
self.keep_seq_len_dim = keep_seq_len_dim
self.additional_last_embedding = additional_last_embedding
model, _ = clip.load(clip_name, device='cpu',jit=False)
model = clip_model.build_model(model.state_dict())
self.token_embedding = model.token_embedding
self.positional_embedding = model.positional_embedding
self.transformer = model.transformer
self.ln_final = model.ln_final
self.text_projection = model.text_projection
if embed_dim == 1024:
self.embed_dim = self.text_projection.shape[1]*2 # to fit 1024 dimension of image embedding
else:
self.embed_dim = self.text_projection.shape[1] # original output, 512 dim
self.trainable = False
self._set_trainable()
@property
def dtype(self):
return self.transformer.resblocks[0].attn.in_proj_weight.dtype
def encode_text(self, text):
text[text < 0] = 0 # some padded text token maybe negative, so set them to 0
x = self.token_embedding(text).type(self.dtype) # [batch_size, n_ctx, d_model]
x = x + self.positional_embedding.type(self.dtype)
x = x.permute(1, 0, 2) # NLD -> LND
x = self.transformer(x)
x = x.permute(1, 0, 2) # LND -> NLD
x = self.ln_final(x).type(self.dtype)
# x.shape = [batch_size, n_ctx, transformer.width]
if self.pick_last_embedding:
# take features from the eot embedding (eot_token is the highest number in each sequence)
x = x[torch.arange(x.shape[0]), text.argmax(dim=-1)] @ self.text_projection # [batch_size, transformer.width]
if self.keep_seq_len_dim:
x = x.unsqueeze(dim=1) # [batch_size, 1, transformer.width]
return x
def forward(self, index, **kwargs):
"""
index: B x L, index
mask: B x L, bool type. The value of False indicating padded index
"""
assert index.dim() == 2 # B x L
text_feature = self.encode_text(index)
if self.embed_dim == 1024:
text_features = torch.cat((text_feature, text_feature), dim=2)
else:
text_features = text_feature
if self.normalize:
text_features = text_features / text_features.norm(dim=-1, keepdim=True)
if self.additional_last_embedding == True:
last_feature = text_feature[torch.arange(text_feature.shape[0]), index.argmax(dim=-1)] @ self.text_projection
if self.keep_seq_len_dim:
last_feature = last_feature.unsqueeze(dim=1)
return text_features, last_feature
return text_features
| 3,423 | 37.47191 | 121 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/utils/misc.py | from numpy.core.fromnumeric import resize
from numpy.lib.function_base import kaiser
from numpy.lib.npyio import save
import torch
import random
import math
from image_synthesis.distributed.distributed import all_reduce, get_world_size
def logits_top_k(logits, filter_ratio = 0.5, minimum=1, pad_value=None):
logits = logits.contiguous()
if filter_ratio < 0:
filter_ratio = - filter_ratio
if filter_ratio >= 0 and filter_ratio <= 1.0:
num_logits = logits.shape[-1]
k = max(int((1 - filter_ratio) * num_logits), minimum)
else:
k = max(int(filter_ratio), minimum)
val, ind = torch.topk(input=logits, k=k, dim=-1)
if pad_value is None:
pad_value = float('-inf')
probs = torch.full_like(logits, pad_value)
# probs.scatter_(1, ind, val)
probs.scatter_(-1, ind, val)
return probs
def mask_with_top_k(x, k, largest=True, abs=True, pad_value=None):
"""
mask the input tensor along the last dimension.
The values the not in the topk will be masked as zeros
"""
if abs:
x_ = x.abs()
else:
x_ = x
_, top_k_index = x_.topk(k=k, dim=-1, largest=largest) # BHW x K
mask = torch.zeros_like(x)
ones = torch.ones_like(x)
mask.scatter_(-1, index=top_k_index, src=ones)
x = x * mask
if pad_value is None or pad_value != 0:
if pad_value is None:
pad_value = float('-inf')
x[mask == 0] = x[mask == 0] + pad_value
return x
def sample_index_randomly(x, k, filter_ratio=0, largest=True):
"""
x: should be 2D tensor, randomly smaple along the lat dimension
"""
assert x.dim() == 2, 'currently only two dimensional tensors are supprted!'
if filter_ratio < 0:
filter_ratio = - filter_ratio
if filter_ratio >= 0 and filter_ratio <= 1.0:
num_logits = x.shape[-1]
topk = max(int((1 - filter_ratio) * num_logits), k)
else:
topk = max(int(filter_ratio), k)
_, top_k_index = x.topk(k=topk, dim=-1, largest=largest) # BHW x K
sampled = []
for i in range(x.shape[0]):
index = top_k_index[i]
sampled_ = torch.tensor(random.sample(index.tolist(), k)).to(index)
sampled.append(sampled_)
sampled = torch.stack(sampled, dim=0).to(top_k_index)
return sampled
def get_token_type(mask, token_shape):
"""
Get the token type according to the given mask and token_shape.
Note that we treat tokens into 3 types.
0: masked tokens
1: unmasked tokens
2: partially masked tokens
Args:
mask: 4D tensor, B x 1 x H x W, the mask of the origin image. 1 denotes masked pixles
and 0 denotes unmasked pixels.
token_shape: [H/r, W/r]. the shape of token
"""
mask_float = mask.float()
mask_unshuffle = pixel_unshuffle(mask_float, token_shape) # B x r^2 x H/r x W/r
scale_factor = mask_unshuffle.shape[1]
mask_unshuffle = mask_unshuffle.sum(dim=1, keepdim=True) # B x 1 x H/r x W/r
token_type = torch.zeros_like(mask_unshuffle).long() + 2
token_type[mask_unshuffle==0] = 0 # unmasked tokens
token_type[mask_unshuffle==scale_factor] = 1 # fully masked tokens
return token_type
def gen_attention_mask(H, W, type='full', causal=True, condition_seq_len=0, **kwargs):
content_seq_len = H * W
seq_len = content_seq_len + condition_seq_len
mask = torch.zeros(seq_len, seq_len)
mask[:, :condition_seq_len] = 1
if type == 'full':
mask += 1
elif type == 'dalle_row':
for idx in range(content_seq_len):
h = idx // W
w = idx % W
for w_ in range(w-W, w+1):
i = h * W + w_
mask[idx+condition_seq_len][i+condition_seq_len] = 1
elif type == 'dalle_col':
for idx in range(content_seq_len):
h = idx // W
w = idx % W
for h_ in range(h+1):
i = h_ * W + w
mask[idx+condition_seq_len][i+condition_seq_len] = 1
elif type == 'dalle_conv':
kernel_size = kwargs['kernel_size']
if isinstance(kernel_size, int):
kernel_size = [kernel_size, kernel_size]
k_h, k_w = kernel_size[0], kernel_size[1]
half_k_h = int(k_h/2)
half_k_w = int(k_w/2)
step_over_w = W - k_w
for idx in range(content_seq_len):
max_kernel_count = (half_k_h+1) * k_w
step_over_count = step_over_w * (half_k_h+1)
max_pre = max_kernel_count + step_over_count
max_pre = min(idx+1, max_pre)
for i in range(max_pre):
valid = False
a = i % W
if a > half_k_w and a <= half_k_w + step_over_w:
valid = False
else:
valid = True
if valid:
mask[idx+condition_seq_len][idx-i+condition_seq_len] = 1
else:
raise NotImplementedError('attention type {} not implemented!'.format(type))
if causal:
causal_mask = torch.tril(torch.ones(content_seq_len+condition_seq_len, content_seq_len+condition_seq_len))
mask *= causal_mask
return mask
| 5,282 | 32.01875 | 114 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/transformers/diffusion_transformer.py | # ------------------------------------------
# VQ-Diffusion
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
# written By Shuyang Gu
# ------------------------------------------
import math
import torch
from torch import nn
import torch.nn.functional as F
from image_synthesis.utils.misc import instantiate_from_config
import numpy as np
from einops import rearrange
from image_synthesis.distributed.distributed import is_primary, get_rank
from inspect import isfunction
from torch.cuda.amp import autocast
from image_synthesis.modeling.transformers.transformer_utils import Text2ImageTransformer
eps = 1e-8
def sum_except_batch(x, num_dims=1):
return x.reshape(*x.shape[:num_dims], -1).sum(-1)
def log_1_min_a(a):
return torch.log(1 - a.exp() + 1e-40)
def log_add_exp(a, b):
maximum = torch.max(a, b)
return maximum + torch.log(torch.exp(a - maximum) + torch.exp(b - maximum))
def extract(a, t, x_shape):
b, *_ = t.shape
out = a.gather(-1, t)
return out.reshape(b, *((1,) * (len(x_shape) - 1)))
def log_categorical(log_x_start, log_prob):
return (log_x_start.exp() * log_prob).sum(dim=1)
def index_to_log_onehot(x, num_classes):
assert x.max().item() < num_classes, \
f'Error: {x.max().item()} >= {num_classes}'
x_onehot = F.one_hot(x, num_classes)
permute_order = (0, -1) + tuple(range(1, len(x.size())))
x_onehot = x_onehot.permute(permute_order)
log_x = torch.log(x_onehot.float().clamp(min=1e-30))
return log_x
def log_onehot_to_index(log_x):
return log_x.argmax(1)
def alpha_schedule(time_step, N=100, att_1 = 0.99999, att_T = 0.000009, ctt_1 = 0.000009, ctt_T = 0.99999):
att = np.arange(0, time_step)/(time_step-1)*(att_T - att_1) + att_1
att = np.concatenate(([1], att))
at = att[1:]/att[:-1]
ctt = np.arange(0, time_step)/(time_step-1)*(ctt_T - ctt_1) + ctt_1
ctt = np.concatenate(([0], ctt))
one_minus_ctt = 1 - ctt
one_minus_ct = one_minus_ctt[1:] / one_minus_ctt[:-1]
ct = 1-one_minus_ct
bt = (1-at-ct)/N
att = np.concatenate((att[1:], [1]))
ctt = np.concatenate((ctt[1:], [0]))
btt = (1-att-ctt)/N
return at, bt, ct, att, btt, ctt
class DiffusionTransformer(nn.Module):
def __init__(
self,
*,
content_emb_config=None,
condition_emb_config=None,
transformer_config=None,
diffusion_step=100,
alpha_init_type='cos',
auxiliary_loss_weight=0,
adaptive_auxiliary_loss=False,
mask_weight=[1,1],
learnable_cf=False,
):
super().__init__()
if condition_emb_config is None:
self.condition_emb = None
else:
# for condition and config, we learn a seperate embedding
self.condition_emb = instantiate_from_config(condition_emb_config)
self.condition_dim = self.condition_emb.embed_dim
transformer_config['params']['diffusion_step'] = diffusion_step
transformer_config['params']['content_emb_config'] = content_emb_config
self.transformer = instantiate_from_config(transformer_config)
self.content_seq_len = transformer_config['params']['content_seq_len']
self.amp = False
self.num_classes = self.transformer.content_emb.num_embed
self.loss_type = 'vb_stochastic'
self.shape = transformer_config['params']['content_seq_len']
self.num_timesteps = diffusion_step
self.parametrization = 'x0'
self.auxiliary_loss_weight = auxiliary_loss_weight
self.adaptive_auxiliary_loss = adaptive_auxiliary_loss
self.mask_weight = mask_weight
if alpha_init_type == "alpha1":
at, bt, ct, att, btt, ctt = alpha_schedule(self.num_timesteps, N=self.num_classes-1)
else:
print("alpha_init_type is Wrong !! ")
at = torch.tensor(at.astype('float64'))
bt = torch.tensor(bt.astype('float64'))
ct = torch.tensor(ct.astype('float64'))
log_at = torch.log(at)
log_bt = torch.log(bt)
log_ct = torch.log(ct)
att = torch.tensor(att.astype('float64'))
btt = torch.tensor(btt.astype('float64'))
ctt = torch.tensor(ctt.astype('float64'))
log_cumprod_at = torch.log(att)
log_cumprod_bt = torch.log(btt)
log_cumprod_ct = torch.log(ctt)
log_1_min_ct = log_1_min_a(log_ct)
log_1_min_cumprod_ct = log_1_min_a(log_cumprod_ct)
assert log_add_exp(log_ct, log_1_min_ct).abs().sum().item() < 1.e-5
assert log_add_exp(log_cumprod_ct, log_1_min_cumprod_ct).abs().sum().item() < 1.e-5
self.diffusion_acc_list = [0] * self.num_timesteps
self.diffusion_keep_list = [0] * self.num_timesteps
# Convert to float32 and register buffers.
self.register_buffer('log_at', log_at.float())
self.register_buffer('log_bt', log_bt.float())
self.register_buffer('log_ct', log_ct.float())
self.register_buffer('log_cumprod_at', log_cumprod_at.float())
self.register_buffer('log_cumprod_bt', log_cumprod_bt.float())
self.register_buffer('log_cumprod_ct', log_cumprod_ct.float())
self.register_buffer('log_1_min_ct', log_1_min_ct.float())
self.register_buffer('log_1_min_cumprod_ct', log_1_min_cumprod_ct.float())
self.register_buffer('Lt_history', torch.zeros(self.num_timesteps))
self.register_buffer('Lt_count', torch.zeros(self.num_timesteps))
self.zero_vector = None
if learnable_cf:
self.empty_text_embed = torch.nn.Parameter(torch.randn(size=(77, 512), requires_grad=True, dtype=torch.float64))
self.prior_rule = 0 # inference rule: 0 for VQ-Diffusion v1, 1 for only high-quality inference, 2 for purity prior
self.prior_ps = 1024 # max number to sample per step
self.prior_weight = 0 # probability adjust parameter, 'r' in Equation.11 of Improved VQ-Diffusion
self.update_n_sample()
self.learnable_cf = learnable_cf
def update_n_sample(self):
if self.num_timesteps == 100:
if self.prior_ps <= 10:
self.n_sample = [1, 6] + [11, 10, 10] * 32 + [11, 15]
else:
self.n_sample = [1, 10] + [11, 10, 10] * 32 + [11, 11]
elif self.num_timesteps == 50:
self.n_sample = [10] + [21, 20] * 24 + [30]
elif self.num_timesteps == 25:
self.n_sample = [21] + [41] * 23 + [60]
elif self.num_timesteps == 10:
self.n_sample = [69] + [102] * 8 + [139]
def multinomial_kl(self, log_prob1, log_prob2): # compute KL loss on log_prob
kl = (log_prob1.exp() * (log_prob1 - log_prob2)).sum(dim=1)
return kl
def q_pred_one_timestep(self, log_x_t, t): # q(xt|xt_1)
log_at = extract(self.log_at, t, log_x_t.shape) # at
log_bt = extract(self.log_bt, t, log_x_t.shape) # bt
log_ct = extract(self.log_ct, t, log_x_t.shape) # ct
log_1_min_ct = extract(self.log_1_min_ct, t, log_x_t.shape) # 1-ct
log_probs = torch.cat(
[
log_add_exp(log_x_t[:,:-1,:]+log_at, log_bt),
log_add_exp(log_x_t[:, -1:, :] + log_1_min_ct, log_ct)
],
dim=1
)
return log_probs
def q_pred(self, log_x_start, t): # q(xt|x0)
# log_x_start can be onehot or not
t = (t + (self.num_timesteps + 1))%(self.num_timesteps + 1)
log_cumprod_at = extract(self.log_cumprod_at, t, log_x_start.shape) # at~
log_cumprod_bt = extract(self.log_cumprod_bt, t, log_x_start.shape) # bt~
log_cumprod_ct = extract(self.log_cumprod_ct, t, log_x_start.shape) # ct~
log_1_min_cumprod_ct = extract(self.log_1_min_cumprod_ct, t, log_x_start.shape) # 1-ct~
log_probs = torch.cat(
[
log_add_exp(log_x_start[:,:-1,:]+log_cumprod_at, log_cumprod_bt),
log_add_exp(log_x_start[:,-1:,:]+log_1_min_cumprod_ct, log_cumprod_ct)
],
dim=1
)
return log_probs
def predict_start(self, log_x_t, cond_emb, t): # p(x0|xt)
x_t = log_onehot_to_index(log_x_t)
if self.amp == True:
with autocast():
out = self.transformer(x_t, cond_emb, t)
else:
out = self.transformer(x_t, cond_emb, t)
assert out.size(0) == x_t.size(0)
assert out.size(1) == self.num_classes-1
assert out.size()[2:] == x_t.size()[1:]
log_pred = F.log_softmax(out.double(), dim=1).float()
batch_size = log_x_t.size()[0]
if self.zero_vector is None or self.zero_vector.shape[0] != batch_size:
self.zero_vector = torch.zeros(batch_size, 1, self.content_seq_len).type_as(log_x_t)- 70
log_pred = torch.cat((log_pred, self.zero_vector), dim=1)
log_pred = torch.clamp(log_pred, -70, 0)
return log_pred
def cf_predict_start(self, log_x_t, cond_emb, t):
return self.predict_start(log_x_t, cond_emb, t)
def q_posterior(self, log_x_start, log_x_t, t): # p_theta(xt_1|xt) = sum(q(xt-1|xt,x0')*p(x0'))
# notice that log_x_t is onehot
assert t.min().item() >= 0 and t.max().item() < self.num_timesteps
batch_size = log_x_start.size()[0]
onehot_x_t = log_onehot_to_index(log_x_t)
mask = (onehot_x_t == self.num_classes-1).unsqueeze(1)
log_one_vector = torch.zeros(batch_size, 1, 1).type_as(log_x_t)
log_zero_vector = torch.log(log_one_vector+1.0e-30).expand(-1, -1, self.content_seq_len)
log_qt = self.q_pred(log_x_t, t) # q(xt|x0)
# log_qt = torch.cat((log_qt[:,:-1,:], log_zero_vector), dim=1)
log_qt = log_qt[:,:-1,:]
log_cumprod_ct = extract(self.log_cumprod_ct, t, log_x_start.shape) # ct~
ct_cumprod_vector = log_cumprod_ct.expand(-1, self.num_classes-1, -1)
# ct_cumprod_vector = torch.cat((ct_cumprod_vector, log_one_vector), dim=1)
log_qt = (~mask)*log_qt + mask*ct_cumprod_vector
log_qt_one_timestep = self.q_pred_one_timestep(log_x_t, t) # q(xt|xt_1)
log_qt_one_timestep = torch.cat((log_qt_one_timestep[:,:-1,:], log_zero_vector), dim=1)
log_ct = extract(self.log_ct, t, log_x_start.shape) # ct
ct_vector = log_ct.expand(-1, self.num_classes-1, -1)
ct_vector = torch.cat((ct_vector, log_one_vector), dim=1)
log_qt_one_timestep = (~mask)*log_qt_one_timestep + mask*ct_vector
# log_x_start = torch.cat((log_x_start, log_zero_vector), dim=1)
# q = log_x_start - log_qt
q = log_x_start[:,:-1,:] - log_qt
q = torch.cat((q, log_zero_vector), dim=1)
q_log_sum_exp = torch.logsumexp(q, dim=1, keepdim=True)
q = q - q_log_sum_exp
log_EV_xtmin_given_xt_given_xstart = self.q_pred(q, t-1) + log_qt_one_timestep + q_log_sum_exp
return torch.clamp(log_EV_xtmin_given_xt_given_xstart, -70, 0)
def p_pred(self, log_x, cond_emb, t): # if x0, first p(x0|xt), than sum(q(xt-1|xt,x0)*p(x0|xt))
if self.parametrization == 'x0':
log_x_recon = self.cf_predict_start(log_x, cond_emb, t)
log_model_pred = self.q_posterior(
log_x_start=log_x_recon, log_x_t=log_x, t=t)
elif self.parametrization == 'direct':
log_model_pred = self.predict_start(log_x, cond_emb, t)
else:
raise ValueError
return log_model_pred, log_x_recon
@torch.no_grad()
def p_sample(self, log_x, cond_emb, t, sampled=None, to_sample=None): # sample q(xt-1) for next step from xt, actually is p(xt-1|xt)
model_log_prob, log_x_recon = self.p_pred(log_x, cond_emb, t)
max_sample_per_step = self.prior_ps # max number to sample per step
if t[0] > 0 and self.prior_rule > 0 and to_sample is not None: # prior_rule: 0 for VQ-Diffusion v1, 1 for only high-quality inference, 2 for purity prior
log_x_idx = log_onehot_to_index(log_x)
if self.prior_rule == 1:
score = torch.ones((log_x.shape[0], log_x.shape[2])).to(log_x.device)
elif self.prior_rule == 2:
score = torch.exp(log_x_recon).max(dim=1).values.clamp(0, 1)
score /= (score.max(dim=1, keepdim=True).values + 1e-10)
if self.prior_rule != 1 and self.prior_weight > 0:
# probability adjust parameter, prior_weight: 'r' in Equation.11 of Improved VQ-Diffusion
prob = ((1 + score * self.prior_weight).unsqueeze(1) * log_x_recon).softmax(dim=1)
prob = prob.log().clamp(-70, 0)
else:
prob = log_x_recon
out = self.log_sample_categorical(prob)
out_idx = log_onehot_to_index(out)
out2_idx = log_x_idx.clone()
_score = score.clone()
if _score.sum() < 1e-6:
_score += 1
_score[log_x_idx != self.num_classes - 1] = 0
for i in range(log_x.shape[0]):
n_sample = min(to_sample - sampled[i], max_sample_per_step)
if to_sample - sampled[i] - n_sample == 1:
n_sample = to_sample - sampled[i]
if n_sample <= 0:
continue
sel = torch.multinomial(_score[i], n_sample)
out2_idx[i][sel] = out_idx[i][sel]
sampled[i] += ((out2_idx[i] != self.num_classes - 1).sum() - (log_x_idx[i] != self.num_classes - 1).sum()).item()
out = index_to_log_onehot(out2_idx, self.num_classes)
else:
# Gumbel sample
out = self.log_sample_categorical(model_log_prob)
sampled = [1024] * log_x.shape[0]
if to_sample is not None:
return out, sampled
else:
return out
def log_sample_categorical(self, logits): # use gumbel to sample onehot vector from log probability
uniform = torch.rand_like(logits)
gumbel_noise = -torch.log(-torch.log(uniform + 1e-30) + 1e-30)
sample = (gumbel_noise + logits).argmax(dim=1)
log_sample = index_to_log_onehot(sample, self.num_classes)
return log_sample
def q_sample(self, log_x_start, t): # diffusion step, q(xt|x0) and sample xt
log_EV_qxt_x0 = self.q_pred(log_x_start, t)
log_sample = self.log_sample_categorical(log_EV_qxt_x0)
return log_sample
def sample_time(self, b, device, method='uniform'):
if method == 'importance':
if not (self.Lt_count > 10).all():
return self.sample_time(b, device, method='uniform')
Lt_sqrt = torch.sqrt(self.Lt_history + 1e-10) + 0.0001
Lt_sqrt[0] = Lt_sqrt[1] # Overwrite decoder term with L1.
pt_all = Lt_sqrt / Lt_sqrt.sum()
t = torch.multinomial(pt_all, num_samples=b, replacement=True)
pt = pt_all.gather(dim=0, index=t)
return t, pt
elif method == 'uniform':
t = torch.randint(0, self.num_timesteps, (b,), device=device).long()
pt = torch.ones_like(t).float() / self.num_timesteps
return t, pt
else:
raise ValueError
def _train_loss(self, x, cond_emb, is_train=True): # get the KL loss
b, device = x.size(0), x.device
assert self.loss_type == 'vb_stochastic'
x_start = x
t, pt = self.sample_time(b, device, 'importance')
log_x_start = index_to_log_onehot(x_start, self.num_classes)
log_xt = self.q_sample(log_x_start=log_x_start, t=t)
xt = log_onehot_to_index(log_xt)
############### go to p_theta function ###############
log_x0_recon = self.predict_start(log_xt, cond_emb, t=t) # P_theta(x0|xt)
log_model_prob = self.q_posterior(log_x_start=log_x0_recon, log_x_t=log_xt, t=t) # go through q(xt_1|xt,x0)
################## compute acc list ################
x0_recon = log_onehot_to_index(log_x0_recon)
x0_real = x_start
xt_1_recon = log_onehot_to_index(log_model_prob)
xt_recon = log_onehot_to_index(log_xt)
for index in range(t.size()[0]):
this_t = t[index].item()
same_rate = (x0_recon[index] == x0_real[index]).sum().cpu()/x0_real.size()[1]
self.diffusion_acc_list[this_t] = same_rate.item()*0.1 + self.diffusion_acc_list[this_t]*0.9
same_rate = (xt_1_recon[index] == xt_recon[index]).sum().cpu()/xt_recon.size()[1]
self.diffusion_keep_list[this_t] = same_rate.item()*0.1 + self.diffusion_keep_list[this_t]*0.9
# compute log_true_prob now
log_true_prob = self.q_posterior(log_x_start=log_x_start, log_x_t=log_xt, t=t)
kl = self.multinomial_kl(log_true_prob, log_model_prob)
mask_region = (xt == self.num_classes-1).float()
mask_weight = mask_region * self.mask_weight[0] + (1. - mask_region) * self.mask_weight[1]
kl = kl * mask_weight
kl = sum_except_batch(kl)
decoder_nll = -log_categorical(log_x_start, log_model_prob)
decoder_nll = sum_except_batch(decoder_nll)
mask = (t == torch.zeros_like(t)).float()
kl_loss = mask * decoder_nll + (1. - mask) * kl
Lt2 = kl_loss.pow(2)
Lt2_prev = self.Lt_history.gather(dim=0, index=t)
new_Lt_history = (0.1 * Lt2 + 0.9 * Lt2_prev).detach()
self.Lt_history.scatter_(dim=0, index=t, src=new_Lt_history)
self.Lt_count.scatter_add_(dim=0, index=t, src=torch.ones_like(Lt2))
# Upweigh loss term of the kl
# vb_loss = kl_loss / pt + kl_prior
loss1 = kl_loss / pt
vb_loss = loss1
if self.auxiliary_loss_weight != 0 and is_train==True:
kl_aux = self.multinomial_kl(log_x_start[:,:-1,:], log_x0_recon[:,:-1,:])
kl_aux = kl_aux * mask_weight
kl_aux = sum_except_batch(kl_aux)
kl_aux_loss = mask * decoder_nll + (1. - mask) * kl_aux
if self.adaptive_auxiliary_loss == True:
addition_loss_weight = (1-t/self.num_timesteps) + 1.0
else:
addition_loss_weight = 1.0
loss2 = addition_loss_weight * self.auxiliary_loss_weight * kl_aux_loss / pt
vb_loss += loss2
return log_model_prob, vb_loss
@property
def device(self):
return self.transformer.to_logits[-1].weight.device
def parameters(self, recurse=True, name=None):
"""
Following minGPT:
This long function is unfortunately doing something very simple and is being very defensive:
We are separating out all parameters of the model into two buckets: those that will experience
weight decay for regularization and those that won't (biases, and layernorm/embedding weights).
We are then returning the PyTorch optimizer object.
"""
# return super().parameters(recurse=True)
if name is None or name == 'none':
return super().parameters(recurse=recurse)
else:
# separate out all parameters to those that will and won't experience regularizing weight decay
print("GPTLikeTransformer: get parameters by the overwrite method!")
decay = set()
no_decay = set()
whitelist_weight_modules = (torch.nn.Linear, )
blacklist_weight_modules = (torch.nn.LayerNorm, torch.nn.Embedding)
for mn, m in self.named_modules():
for pn, p in m.named_parameters():
fpn = '%s.%s' % (mn, pn) if mn else pn # full param name
if pn.endswith('bias'):
# all biases will not be decayed
no_decay.add(fpn)
elif pn.endswith('weight') and isinstance(m, whitelist_weight_modules):
# weights of whitelist modules will be weight decayed
decay.add(fpn)
elif pn.endswith('weight') and isinstance(m, blacklist_weight_modules):
# weights of blacklist modules will NOT be weight decayed
no_decay.add(fpn)
# special case the position embedding parameter as not decayed
module_name = ['condition_emb', 'content_emb']
pos_emb_name = ['pos_emb', 'width_emb', 'height_emb', 'pad_emb', 'token_type_emb']
for mn in module_name:
if hasattr(self, mn) and getattr(self, mn) is not None:
for pn in pos_emb_name:
if hasattr(getattr(self, mn), pn):
if isinstance(getattr(getattr(self, mn), pn), torch.nn.Parameter):
no_decay.add('{}.{}'.format(mn, pn))
# validate that we considered every parameter
param_dict = {pn: p for pn, p in self.transformer.named_parameters()}# if p.requires_grad}
inter_params = decay & no_decay
union_params = decay | no_decay
assert len(inter_params) == 0, "parameters %s made it into both decay/no_decay sets!" % (str(inter_params), )
assert len(param_dict.keys() - union_params) == 0, "parameters %s were not separated into either decay/no_decay set!" \
% (str(param_dict.keys() - union_params), )
# create the pytorch optimizer object
optim_groups = [
{"params": [param_dict[pn] for pn in sorted(list(decay))], "weight_decay": 0.01},
{"params": [param_dict[pn] for pn in sorted(list(no_decay))], "weight_decay": 0.0},
]
return optim_groups
def forward(
self,
input,
return_loss=False,
return_logits=True,
return_att_weight=False,
is_train=True,
**kwargs):
if kwargs.get('autocast') == True:
self.amp = True
batch_size = input['content_token'].shape[0]
device = input['content_token'].device
# 1) get embeddding for condition and content prepare input
sample_image = input['content_token'].type_as(input['content_token'])
# cont_emb = self.content_emb(sample_image)
if self.condition_emb is not None:
with autocast(enabled=False):
with torch.no_grad():
cond_emb = self.condition_emb(input['condition_token']) # B x Ld x D #256*1024
if self.learnable_cf:
is_empty_text = torch.logical_not(input['condition_mask'][:, 2]).unsqueeze(1).unsqueeze(2).repeat(1, 77, 512)
cond_emb = torch.where(is_empty_text, self.empty_text_embed.unsqueeze(0).repeat(cond_emb.shape[0], 1, 1), cond_emb.type_as(self.empty_text_embed))
cond_emb = cond_emb.float()
else: # share condition embeding with content
if input.get('condition_embed_token') == None:
cond_emb = None
else:
cond_emb = input['condition_embed_token'].float()
# now we get cond_emb and sample_image
if is_train == True:
log_model_prob, loss = self._train_loss(sample_image, cond_emb)
loss = loss.sum()/(sample_image.size()[0] * sample_image.size()[1])
# 4) get output, especially loss
out = {}
if return_logits:
out['logits'] = torch.exp(log_model_prob)
if return_loss:
out['loss'] = loss
self.amp = False
return out
def sample(
self,
condition_token,
condition_mask,
condition_embed,
content_token = None,
filter_ratio = 0.5,
temperature = 1.0,
return_att_weight = False,
return_logits = False,
content_logits = None,
print_log = True,
**kwargs):
input = {'condition_token': condition_token,
'content_token': content_token,
'condition_mask': condition_mask,
'condition_embed_token': condition_embed,
'content_logits': content_logits,
}
if input['condition_token'] != None:
batch_size = input['condition_token'].shape[0]
else:
batch_size = kwargs['batch_size']
device = self.log_at.device
start_step = int(self.num_timesteps * filter_ratio)
# get cont_emb and cond_emb
if content_token != None:
sample_image = input['content_token'].type_as(input['content_token'])
if self.condition_emb is not None: # do this
with torch.no_grad():
cond_emb = self.condition_emb(input['condition_token']) # B x Ld x D #256*1024
cond_emb = cond_emb.float()
else: # share condition embeding with content
if input.get('condition_embed_token', None) != None:
cond_emb = input['condition_embed_token'].float()
else:
cond_emb = None
if start_step == 0:
# use full mask sample
zero_logits = torch.zeros((batch_size, self.num_classes-1, self.shape),device=device)
one_logits = torch.ones((batch_size, 1, self.shape),device=device)
mask_logits = torch.cat((zero_logits, one_logits), dim=1)
log_z = torch.log(mask_logits)
start_step = self.num_timesteps
with torch.no_grad():
for diffusion_index in range(start_step-1, -1, -1):
t = torch.full((batch_size,), diffusion_index, device=device, dtype=torch.long)
sampled = [0] * log_z.shape[0]
while min(sampled) < self.n_sample[diffusion_index]:
log_z, sampled = self.p_sample(log_z, cond_emb, t, sampled, self.n_sample[diffusion_index]) # log_z is log_onehot
else:
t = torch.full((batch_size,), start_step-1, device=device, dtype=torch.long)
log_x_start = index_to_log_onehot(sample_image, self.num_classes)
log_xt = self.q_sample(log_x_start=log_x_start, t=t)
log_z = log_xt
with torch.no_grad():
for diffusion_index in range(start_step-1, -1, -1):
t = torch.full((batch_size,), diffusion_index, device=device, dtype=torch.long)
log_z = self.p_sample(log_z, cond_emb, t) # log_z is log_onehot
content_token = log_onehot_to_index(log_z)
output = {'content_token': content_token}
if return_logits:
output['logits'] = torch.exp(log_z)
return output
def sample_fast(
self,
condition_token,
condition_mask,
condition_embed,
content_token = None,
filter_ratio = 0.5,
temperature = 1.0,
return_att_weight = False,
return_logits = False,
content_logits = None,
print_log = True,
skip_step = 1,
**kwargs):
input = {'condition_token': condition_token,
'content_token': content_token,
'condition_mask': condition_mask,
'condition_embed_token': condition_embed,
'content_logits': content_logits,
}
batch_size = input['condition_token'].shape[0]
device = self.log_at.device
start_step = int(self.num_timesteps * filter_ratio)
# get cont_emb and cond_emb
if content_token != None:
sample_image = input['content_token'].type_as(input['content_token'])
if self.condition_emb is not None:
with torch.no_grad():
cond_emb = self.condition_emb(input['condition_token']) # B x Ld x D #256*1024
cond_emb = cond_emb.float()
else: # share condition embeding with content
cond_emb = input['condition_embed_token'].float()
assert start_step == 0
zero_logits = torch.zeros((batch_size, self.num_classes-1, self.shape),device=device)
one_logits = torch.ones((batch_size, 1, self.shape),device=device)
mask_logits = torch.cat((zero_logits, one_logits), dim=1)
log_z = torch.log(mask_logits)
start_step = self.num_timesteps
with torch.no_grad():
# skip_step = 1
diffusion_list = [index for index in range(start_step-1, -1, -1-skip_step)]
if diffusion_list[-1] != 0:
diffusion_list.append(0)
# for diffusion_index in range(start_step-1, -1, -1):
for diffusion_index in diffusion_list:
t = torch.full((batch_size,), diffusion_index, device=device, dtype=torch.long)
log_x_recon = self.cf_predict_start(log_z, cond_emb, t)
if diffusion_index > skip_step:
model_log_prob = self.q_posterior(log_x_start=log_x_recon, log_x_t=log_z, t=t-skip_step)
else:
model_log_prob = self.q_posterior(log_x_start=log_x_recon, log_x_t=log_z, t=t)
log_z = self.log_sample_categorical(model_log_prob)
content_token = log_onehot_to_index(log_z)
output = {'content_token': content_token}
if return_logits:
output['logits'] = torch.exp(log_z)
return output
| 29,919 | 42.678832 | 166 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/modeling/transformers/transformer_utils.py | # ------------------------------------------
# VQ-Diffusion
# Copyright (c) Microsoft Corporation.
# Licensed under the MIT License.
# written By Shuyang Gu
# ------------------------------------------
import math
import torch
from torch import nn
import torch.nn.functional as F
from image_synthesis.utils.misc import instantiate_from_config
import numpy as np
from einops import rearrange
from image_synthesis.distributed.distributed import is_primary, get_rank
from inspect import isfunction
from torch.cuda.amp import autocast
from torch.utils.checkpoint import checkpoint
class FullAttention(nn.Module):
def __init__(self,
n_embd, # the embed dim
n_head, # the number of heads
seq_len=None, # the max length of sequence
attn_pdrop=0.1, # attention dropout prob
resid_pdrop=0.1, # residual attention dropout prob
causal=True,
):
super().__init__()
assert n_embd % n_head == 0
# key, query, value projections for all heads
self.key = nn.Linear(n_embd, n_embd)
self.query = nn.Linear(n_embd, n_embd)
self.value = nn.Linear(n_embd, n_embd)
# regularization
self.attn_drop = nn.Dropout(attn_pdrop)
self.resid_drop = nn.Dropout(resid_pdrop)
# output projection
self.proj = nn.Linear(n_embd, n_embd)
self.n_head = n_head
self.causal = causal
def forward(self, x, encoder_output, mask=None):
B, T, C = x.size()
k = self.key(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
q = self.query(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
v = self.value(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1))) # (B, nh, T, T)
att = F.softmax(att, dim=-1) # (B, nh, T, T)
att = self.attn_drop(att)
y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs)
y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side, (B, T, C)
att = att.mean(dim=1, keepdim=False) # (B, T, T)
# output projection
y = self.resid_drop(self.proj(y))
return y, att
class CrossAttention(nn.Module):
def __init__(self,
condition_seq_len,
n_embd, # the embed dim
condition_embd, # condition dim
n_head, # the number of heads
seq_len=None, # the max length of sequence
attn_pdrop=0.1, # attention dropout prob
resid_pdrop=0.1, # residual attention dropout prob
causal=True,
):
super().__init__()
assert n_embd % n_head == 0
# key, query, value projections for all heads
self.key = nn.Linear(condition_embd, n_embd)
self.query = nn.Linear(n_embd, n_embd)
self.value = nn.Linear(condition_embd, n_embd)
# regularization
self.attn_drop = nn.Dropout(attn_pdrop)
self.resid_drop = nn.Dropout(resid_pdrop)
# output projection
self.proj = nn.Linear(n_embd, n_embd)
self.n_head = n_head
self.causal = causal
# causal mask to ensure that attention is only applied to the left in the input sequence
if self.causal:
self.register_buffer("mask", torch.tril(torch.ones(seq_len, seq_len))
.view(1, 1, seq_len, seq_len))
def forward(self, x, encoder_output, mask=None):
B, T, C = x.size()
B, T_E, _ = encoder_output.size()
# calculate query, key, values for all heads in batch and move head forward to be the batch dim
k = self.key(encoder_output).view(B, T_E, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
q = self.query(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
v = self.value(encoder_output).view(B, T_E, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1))) # (B, nh, T, T)
att = F.softmax(att, dim=-1) # (B, nh, T, T)
att = self.attn_drop(att)
y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs)
y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side, (B, T, C)
att = att.mean(dim=1, keepdim=False) # (B, T, T)
# output projection
y = self.resid_drop(self.proj(y))
return y, att
class GELU2(nn.Module):
def __init__(self):
super().__init__()
def forward(self, x):
return x * F.sigmoid(1.702 * x)
class SinusoidalPosEmb(nn.Module):
def __init__(self, num_steps, dim, rescale_steps=4000):
super().__init__()
self.dim = dim
self.num_steps = float(num_steps)
self.rescale_steps = float(rescale_steps)
def forward(self, x):
x = x / self.num_steps * self.rescale_steps
device = x.device
half_dim = self.dim // 2
emb = math.log(10000) / (half_dim - 1)
emb = torch.exp(torch.arange(half_dim, device=device) * -emb)
emb = x[:, None] * emb[None, :]
emb = torch.cat((emb.sin(), emb.cos()), dim=-1)
return emb
class AdaLayerNorm(nn.Module):
def __init__(self, n_embd, diffusion_step, emb_type="adalayernorm_abs"):
super().__init__()
if "abs" in emb_type:
self.emb = SinusoidalPosEmb(diffusion_step, n_embd)
else:
self.emb = nn.Embedding(diffusion_step, n_embd)
self.silu = nn.SiLU()
self.linear = nn.Linear(n_embd, n_embd*2)
self.layernorm = nn.LayerNorm(n_embd, elementwise_affine=False)
self.diff_step = diffusion_step
def forward(self, x, timestep):
if timestep[0] >= self.diff_step:
_emb = self.emb.weight.mean(dim=0, keepdim=True).repeat(len(timestep), 1)
emb = self.linear(self.silu(_emb)).unsqueeze(1)
else:
emb = self.linear(self.silu(self.emb(timestep))).unsqueeze(1)
scale, shift = torch.chunk(emb, 2, dim=2)
x = self.layernorm(x) * (1 + scale) + shift
return x
class AdaInsNorm(nn.Module):
def __init__(self, n_embd, diffusion_step, emb_type="adainsnorm_abs"):
super().__init__()
if "abs" in emb_type:
self.emb = SinusoidalPosEmb(diffusion_step, n_embd)
else:
self.emb = nn.Embedding(diffusion_step, n_embd)
self.silu = nn.SiLU()
self.linear = nn.Linear(n_embd, n_embd*2)
self.instancenorm = nn.InstanceNorm1d(n_embd)
def forward(self, x, timestep):
emb = self.linear(self.silu(self.emb(timestep))).unsqueeze(1)
scale, shift = torch.chunk(emb, 2, dim=2)
x = self.instancenorm(x.transpose(-1, -2)).transpose(-1,-2) * (1 + scale) + shift
return x
class Block(nn.Module):
""" an unassuming Transformer block """
def __init__(self,
class_type='adalayernorm',
class_number=1000,
condition_seq_len=77,
n_embd=1024,
n_head=16,
seq_len=256,
attn_pdrop=0.1,
resid_pdrop=0.1,
mlp_hidden_times=4,
activate='GELU',
attn_type='full',
if_upsample=False,
upsample_type='bilinear',
upsample_pre_channel=0,
content_spatial_size=None, # H , W
conv_attn_kernel_size=None, # only need for dalle_conv attention
condition_dim=1024,
diffusion_step=100,
timestep_type='adalayernorm',
window_size = 8,
mlp_type = 'fc',
):
super().__init__()
self.if_upsample = if_upsample
self.attn_type = attn_type
if attn_type in ['selfcross', 'selfcondition', 'self']:
if 'adalayernorm' in timestep_type:
self.ln1 = AdaLayerNorm(n_embd, diffusion_step, timestep_type)
else:
print("timestep_type wrong")
else:
self.ln1 = nn.LayerNorm(n_embd)
self.ln2 = nn.LayerNorm(n_embd)
# self.if_selfcross = False
if attn_type in ['self', 'selfcondition']:
self.attn = FullAttention(
n_embd=n_embd,
n_head=n_head,
seq_len=seq_len,
attn_pdrop=attn_pdrop,
resid_pdrop=resid_pdrop,
)
if attn_type == 'selfcondition':
if 'adalayernorm' in class_type:
self.ln2 = AdaLayerNorm(n_embd, class_number, class_type)
else:
self.ln2 = AdaInsNorm(n_embd, class_number, class_type)
elif attn_type == 'selfcross':
self.attn1 = FullAttention(
n_embd=n_embd,
n_head=n_head,
seq_len=seq_len,
attn_pdrop=attn_pdrop,
resid_pdrop=resid_pdrop,
)
self.attn2 = CrossAttention(
condition_seq_len,
n_embd=n_embd,
condition_embd=condition_dim,
n_head=n_head,
seq_len=seq_len,
attn_pdrop=attn_pdrop,
resid_pdrop=resid_pdrop,
)
if 'adalayernorm' in timestep_type:
self.ln1_1 = AdaLayerNorm(n_embd, diffusion_step, timestep_type)
else:
print("timestep_type wrong")
else:
print("attn_type error")
assert activate in ['GELU', 'GELU2']
act = nn.GELU() if activate == 'GELU' else GELU2()
if mlp_type == 'conv_mlp':
self.mlp = Conv_MLP(n_embd, mlp_hidden_times, act, resid_pdrop)
else:
self.mlp = nn.Sequential(
nn.Linear(n_embd, mlp_hidden_times * n_embd),
act,
nn.Linear(mlp_hidden_times * n_embd, n_embd),
nn.Dropout(resid_pdrop),
)
def forward(self, x, encoder_output, timestep, mask=None):
if self.attn_type == "selfcross":
a, att = self.attn1(self.ln1(x, timestep), encoder_output, mask=mask)
x = x + a
a, att = self.attn2(self.ln1_1(x, timestep), encoder_output, mask=mask)
x = x + a
elif self.attn_type == "selfcondition":
a, att = self.attn(self.ln1(x, timestep), encoder_output, mask=mask)
x = x + a
x = x + self.mlp(self.ln2(x, encoder_output.long())) # only one really use encoder_output
return x, att
else: # 'self'
a, att = self.attn(self.ln1(x, timestep), encoder_output, mask=mask)
x = x + a
x = x + self.mlp(self.ln2(x))
return x, att
class Conv_MLP(nn.Module):
def __init__(self, n_embd, mlp_hidden_times, act, resid_pdrop):
super().__init__()
self.conv1 = nn.Conv2d(in_channels=n_embd, out_channels=int(mlp_hidden_times * n_embd), kernel_size=3, stride=1, padding=1)
self.act = act
self.conv2 = nn.Conv2d(in_channels=int(mlp_hidden_times * n_embd), out_channels=n_embd, kernel_size=3, stride=1, padding=1)
self.dropout = nn.Dropout(resid_pdrop)
def forward(self, x):
n = x.size()[1]
x = rearrange(x, 'b (h w) c -> b c h w', h=int(math.sqrt(n)))
x = self.conv2(self.act(self.conv1(x)))
x = rearrange(x, 'b c h w -> b (h w) c')
return self.dropout(x)
class Text2ImageTransformer(nn.Module):
def __init__(
self,
condition_seq_len=77,
n_layer=14,
n_embd=1024,
n_head=16,
content_seq_len=1024,
attn_pdrop=0,
resid_pdrop=0,
mlp_hidden_times=4,
block_activate=None,
attn_type='selfcross',
content_spatial_size=[32,32], # H , W
condition_dim=512,
diffusion_step=1000,
timestep_type='adalayernorm',
content_emb_config=None,
mlp_type='fc',
checkpoint=False,
):
super().__init__()
self.use_checkpoint = checkpoint
self.content_emb = instantiate_from_config(content_emb_config)
# transformer
assert attn_type == 'selfcross'
all_attn_type = [attn_type] * n_layer
if content_spatial_size is None:
s = int(math.sqrt(content_seq_len))
assert s * s == content_seq_len
content_spatial_size = (s, s)
self.blocks = nn.Sequential(*[Block(
condition_seq_len,
n_embd=n_embd,
n_head=n_head,
seq_len=content_seq_len,
attn_pdrop=attn_pdrop,
resid_pdrop=resid_pdrop,
mlp_hidden_times=mlp_hidden_times,
activate=block_activate,
attn_type=all_attn_type[n],
content_spatial_size=content_spatial_size, # H , W
condition_dim = condition_dim,
diffusion_step = diffusion_step,
timestep_type = timestep_type,
mlp_type = mlp_type,
) for n in range(n_layer)])
# final prediction head
out_cls = self.content_emb.num_embed-1
self.to_logits = nn.Sequential(
nn.LayerNorm(n_embd),
nn.Linear(n_embd, out_cls),
)
self.condition_seq_len = condition_seq_len
self.content_seq_len = content_seq_len
self.apply(self._init_weights)
def _init_weights(self, module):
if isinstance(module, (nn.Linear, nn.Embedding)):
module.weight.data.normal_(mean=0.0, std=0.02)
if isinstance(module, nn.Linear) and module.bias is not None:
module.bias.data.zero_()
elif isinstance(module, nn.LayerNorm):
if module.elementwise_affine == True:
module.bias.data.zero_()
module.weight.data.fill_(1.0)
def parameters(self, recurse=True, name=None):
"""
Following minGPT:
This long function is unfortunately doing something very simple and is being very defensive:
We are separating out all parameters of the model into two buckets: those that will experience
weight decay for regularization and those that won't (biases, and layernorm/embedding weights).
We are then returning the PyTorch optimizer object.
"""
# return super().parameters(recurse=True)
if name is None or name == 'none':
return super().parameters(recurse=recurse)
else:
# separate out all parameters to those that will and won't experience regularizing weight decay
print("GPTLikeTransformer: get parameters by the overwrite method!")
decay = set()
no_decay = set()
whitelist_weight_modules = (torch.nn.Linear, )
blacklist_weight_modules = (torch.nn.LayerNorm, torch.nn.Embedding)
for mn, m in self.named_modules():
for pn, p in m.named_parameters():
fpn = '%s.%s' % (mn, pn) if mn else pn # full param name
if pn.endswith('bias'):
# all biases will not be decayed
no_decay.add(fpn)
elif pn.endswith('weight') and isinstance(m, whitelist_weight_modules):
# weights of whitelist modules will be weight decayed
decay.add(fpn)
elif pn.endswith('weight') and isinstance(m, blacklist_weight_modules):
# weights of blacklist modules will NOT be weight decayed
no_decay.add(fpn)
# special case the position embedding parameter as not decayed
module_name = ['condition_emb', 'content_emb']
pos_emb_name = ['pos_emb', 'width_emb', 'height_emb', 'pad_emb', 'token_type_emb']
for mn in module_name:
if hasattr(self, mn) and getattr(self, mn) is not None:
for pn in pos_emb_name:
if hasattr(getattr(self, mn), pn):
if isinstance(getattr(getattr(self, mn), pn), torch.nn.Parameter):
no_decay.add('{}.{}'.format(mn, pn))
# validate that we considered every parameter
param_dict = {pn: p for pn, p in self.transformer.named_parameters()}# if p.requires_grad}
inter_params = decay & no_decay
union_params = decay | no_decay
assert len(inter_params) == 0, "parameters %s made it into both decay/no_decay sets!" % (str(inter_params), )
assert len(param_dict.keys() - union_params) == 0, "parameters %s were not separated into either decay/no_decay set!" \
% (str(param_dict.keys() - union_params), )
# create the pytorch optimizer object
optim_groups = [
{"params": [param_dict[pn] for pn in sorted(list(decay))], "weight_decay": 0.01},
{"params": [param_dict[pn] for pn in sorted(list(no_decay))], "weight_decay": 0.0},
]
return optim_groups
def forward(
self,
input,
cond_emb,
t):
cont_emb = self.content_emb(input)
emb = cont_emb
for block_idx in range(len(self.blocks)):
if self.use_checkpoint == False:
emb, att_weight = self.blocks[block_idx](emb, cond_emb, t.cuda()) # B x (Ld+Lt) x D, B x (Ld+Lt) x (Ld+Lt)
else:
emb, att_weight = checkpoint(self.blocks[block_idx], emb, cond_emb, t.cuda())
logits = self.to_logits(emb) # B x (Ld+Lt) x n
out = rearrange(logits, 'b l c -> b c l')
return out
class Condition2ImageTransformer(nn.Module):
def __init__(
self,
class_type='adalayernorm',
class_number=1000,
n_layer=24,
n_embd=1024,
n_head=16,
content_seq_len=1024,
attn_pdrop=0,
resid_pdrop=0,
mlp_hidden_times=4,
block_activate=None,
attn_type='selfcondition',
content_spatial_size=[32,32], # H , W
diffusion_step=100,
timestep_type='adalayernorm',
content_emb_config=None,
mlp_type="conv_mlp",
):
super().__init__()
self.content_emb = instantiate_from_config(content_emb_config)
# transformer
assert attn_type == 'selfcondition'
all_attn_type = [attn_type] * n_layer
if content_spatial_size is None:
s = int(math.sqrt(content_seq_len))
assert s * s == content_seq_len
content_spatial_size = (s, s)
self.blocks = nn.Sequential(*[Block(
class_type=class_type,
class_number=class_number,
n_embd=n_embd,
n_head=n_head,
seq_len=content_seq_len,
attn_pdrop=attn_pdrop,
resid_pdrop=resid_pdrop,
mlp_hidden_times=mlp_hidden_times,
activate=block_activate,
attn_type=all_attn_type[n],
content_spatial_size=content_spatial_size, # H , W
diffusion_step = diffusion_step,
timestep_type = timestep_type,
mlp_type = mlp_type,
) for n in range(n_layer)])
# final prediction head
out_cls = self.content_emb.num_embed-1
self.to_logits = nn.Sequential(
nn.LayerNorm(n_embd),
nn.Linear(n_embd, out_cls),
)
self.content_seq_len = content_seq_len
self.apply(self._init_weights)
def _init_weights(self, module):
if isinstance(module, (nn.Linear, nn.Embedding)):
module.weight.data.normal_(mean=0.0, std=0.02)
if isinstance(module, nn.Linear) and module.bias is not None:
module.bias.data.zero_()
elif isinstance(module, nn.LayerNorm):
if module.elementwise_affine == True:
module.bias.data.zero_()
module.weight.data.fill_(1.0)
def parameters(self, recurse=True, name=None):
"""
Following minGPT:
This long function is unfortunately doing something very simple and is being very defensive:
We are separating out all parameters of the model into two buckets: those that will experience
weight decay for regularization and those that won't (biases, and layernorm/embedding weights).
We are then returning the PyTorch optimizer object.
"""
# return super().parameters(recurse=True)
if name is None or name == 'none':
return super().parameters(recurse=recurse)
else:
# separate out all parameters to those that will and won't experience regularizing weight decay
print("GPTLikeTransformer: get parameters by the overwrite method!")
decay = set()
no_decay = set()
whitelist_weight_modules = (torch.nn.Linear, )
blacklist_weight_modules = (torch.nn.LayerNorm, torch.nn.Embedding)
for mn, m in self.named_modules():
for pn, p in m.named_parameters():
fpn = '%s.%s' % (mn, pn) if mn else pn # full param name
if pn.endswith('bias'):
# all biases will not be decayed
no_decay.add(fpn)
elif pn.endswith('weight') and isinstance(m, whitelist_weight_modules):
# weights of whitelist modules will be weight decayed
decay.add(fpn)
elif pn.endswith('weight') and isinstance(m, blacklist_weight_modules):
# weights of blacklist modules will NOT be weight decayed
no_decay.add(fpn)
# special case the position embedding parameter as not decayed
module_name = ['condition_emb', 'content_emb']
pos_emb_name = ['pos_emb', 'width_emb', 'height_emb', 'pad_emb', 'token_type_emb']
for mn in module_name:
if hasattr(self, mn) and getattr(self, mn) is not None:
for pn in pos_emb_name:
if hasattr(getattr(self, mn), pn):
if isinstance(getattr(getattr(self, mn), pn), torch.nn.Parameter):
no_decay.add('{}.{}'.format(mn, pn))
# validate that we considered every parameter
param_dict = {pn: p for pn, p in self.transformer.named_parameters()}# if p.requires_grad}
inter_params = decay & no_decay
union_params = decay | no_decay
assert len(inter_params) == 0, "parameters %s made it into both decay/no_decay sets!" % (str(inter_params), )
assert len(param_dict.keys() - union_params) == 0, "parameters %s were not separated into either decay/no_decay set!" \
% (str(param_dict.keys() - union_params), )
# create the pytorch optimizer object
optim_groups = [
{"params": [param_dict[pn] for pn in sorted(list(decay))], "weight_decay": 0.01},
{"params": [param_dict[pn] for pn in sorted(list(no_decay))], "weight_decay": 0.0},
]
return optim_groups
def forward(
self,
input,
cond_emb,
t):
cont_emb = self.content_emb(input)
emb = cont_emb
for block_idx in range(len(self.blocks)):
emb, att_weight = self.blocks[block_idx](emb, cond_emb, t.cuda()) # B x (Ld+Lt) x D, B x (Ld+Lt) x (Ld+Lt)
logits = self.to_logits(emb) # B x (Ld+Lt) x n
out = rearrange(logits, 'b l c -> b c l')
return out
class UnCondition2ImageTransformer(nn.Module):
def __init__(
self,
class_type='adalayernorm',
n_layer=24,
n_embd=512,
n_head=16,
content_seq_len=256,
attn_pdrop=0,
resid_pdrop=0,
mlp_hidden_times=4,
block_activate=None,
attn_type='self',
content_spatial_size=[16,16], # H , W
diffusion_step=100,
timestep_type='adalayernorm',
content_emb_config=None,
mlp_type="conv_mlp",
):
super().__init__()
self.content_emb = instantiate_from_config(content_emb_config)
# transformer
assert attn_type == 'self'
all_attn_type = [attn_type] * n_layer
if content_spatial_size is None:
s = int(math.sqrt(content_seq_len))
assert s * s == content_seq_len
content_spatial_size = (s, s)
self.blocks = nn.Sequential(*[Block(
n_embd=n_embd,
n_head=n_head,
seq_len=content_seq_len,
attn_pdrop=attn_pdrop,
resid_pdrop=resid_pdrop,
mlp_hidden_times=mlp_hidden_times,
activate=block_activate,
attn_type=all_attn_type[n],
content_spatial_size=content_spatial_size, # H , W
diffusion_step = diffusion_step,
timestep_type = timestep_type,
mlp_type = mlp_type,
) for n in range(n_layer)])
# final prediction head
out_cls = self.content_emb.num_embed-1
self.to_logits = nn.Sequential(
nn.LayerNorm(n_embd),
nn.Linear(n_embd, out_cls),
)
self.content_seq_len = content_seq_len
self.apply(self._init_weights)
def _init_weights(self, module):
if isinstance(module, (nn.Linear, nn.Embedding)):
module.weight.data.normal_(mean=0.0, std=0.02)
if isinstance(module, nn.Linear) and module.bias is not None:
module.bias.data.zero_()
elif isinstance(module, nn.LayerNorm):
if module.elementwise_affine == True:
module.bias.data.zero_()
module.weight.data.fill_(1.0)
def parameters(self, recurse=True, name=None):
"""
Following minGPT:
This long function is unfortunately doing something very simple and is being very defensive:
We are separating out all parameters of the model into two buckets: those that will experience
weight decay for regularization and those that won't (biases, and layernorm/embedding weights).
We are then returning the PyTorch optimizer object.
"""
# return super().parameters(recurse=True)
if name is None or name == 'none':
return super().parameters(recurse=recurse)
else:
# separate out all parameters to those that will and won't experience regularizing weight decay
print("GPTLikeTransformer: get parameters by the overwrite method!")
decay = set()
no_decay = set()
whitelist_weight_modules = (torch.nn.Linear, )
blacklist_weight_modules = (torch.nn.LayerNorm, torch.nn.Embedding)
for mn, m in self.named_modules():
for pn, p in m.named_parameters():
fpn = '%s.%s' % (mn, pn) if mn else pn # full param name
if pn.endswith('bias'):
# all biases will not be decayed
no_decay.add(fpn)
elif pn.endswith('weight') and isinstance(m, whitelist_weight_modules):
# weights of whitelist modules will be weight decayed
decay.add(fpn)
elif pn.endswith('weight') and isinstance(m, blacklist_weight_modules):
# weights of blacklist modules will NOT be weight decayed
no_decay.add(fpn)
# special case the position embedding parameter as not decayed
module_name = ['condition_emb', 'content_emb']
pos_emb_name = ['pos_emb', 'width_emb', 'height_emb', 'pad_emb', 'token_type_emb']
for mn in module_name:
if hasattr(self, mn) and getattr(self, mn) is not None:
for pn in pos_emb_name:
if hasattr(getattr(self, mn), pn):
if isinstance(getattr(getattr(self, mn), pn), torch.nn.Parameter):
no_decay.add('{}.{}'.format(mn, pn))
# validate that we considered every parameter
param_dict = {pn: p for pn, p in self.transformer.named_parameters()}# if p.requires_grad}
inter_params = decay & no_decay
union_params = decay | no_decay
assert len(inter_params) == 0, "parameters %s made it into both decay/no_decay sets!" % (str(inter_params), )
assert len(param_dict.keys() - union_params) == 0, "parameters %s were not separated into either decay/no_decay set!" \
% (str(param_dict.keys() - union_params), )
# create the pytorch optimizer object
optim_groups = [
{"params": [param_dict[pn] for pn in sorted(list(decay))], "weight_decay": 0.01},
{"params": [param_dict[pn] for pn in sorted(list(no_decay))], "weight_decay": 0.0},
]
return optim_groups
def forward(
self,
input,
cond_emb,
t):
cont_emb = self.content_emb(input)
emb = cont_emb
for block_idx in range(len(self.blocks)):
emb, att_weight = self.blocks[block_idx](emb, cond_emb, t.cuda()) # B x (Ld+Lt) x D, B x (Ld+Lt) x (Ld+Lt)
logits = self.to_logits(emb) # B x (Ld+Lt) x n
out = rearrange(logits, 'b l c -> b c l')
return out
| 30,407 | 41 | 131 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/taming/modules/util.py | import torch
import torch.nn as nn
def count_params(model):
total_params = sum(p.numel() for p in model.parameters())
return total_params
class ActNorm(nn.Module):
def __init__(self, num_features, logdet=False, affine=True,
allow_reverse_init=False):
assert affine
super().__init__()
self.logdet = logdet
self.loc = nn.Parameter(torch.zeros(1, num_features, 1, 1))
self.scale = nn.Parameter(torch.ones(1, num_features, 1, 1))
self.allow_reverse_init = allow_reverse_init
self.register_buffer('initialized', torch.tensor(0, dtype=torch.uint8))
def initialize(self, input):
with torch.no_grad():
flatten = input.permute(1, 0, 2, 3).contiguous().view(input.shape[1], -1)
mean = (
flatten.mean(1)
.unsqueeze(1)
.unsqueeze(2)
.unsqueeze(3)
.permute(1, 0, 2, 3)
)
std = (
flatten.std(1)
.unsqueeze(1)
.unsqueeze(2)
.unsqueeze(3)
.permute(1, 0, 2, 3)
)
self.loc.data.copy_(-mean)
self.scale.data.copy_(1 / (std + 1e-6))
def forward(self, input, reverse=False):
if reverse:
return self.reverse(input)
if len(input.shape) == 2:
input = input[:,:,None,None]
squeeze = True
else:
squeeze = False
_, _, height, width = input.shape
if self.training and self.initialized.item() == 0:
self.initialize(input)
self.initialized.fill_(1)
h = self.scale * (input + self.loc)
if squeeze:
h = h.squeeze(-1).squeeze(-1)
if self.logdet:
log_abs = torch.log(torch.abs(self.scale))
logdet = height*width*torch.sum(log_abs)
logdet = logdet * torch.ones(input.shape[0]).to(input)
return h, logdet
return h
def reverse(self, output):
if self.training and self.initialized.item() == 0:
if not self.allow_reverse_init:
raise RuntimeError(
"Initializing ActNorm in reverse direction is "
"disabled by default. Use allow_reverse_init=True to enable."
)
else:
self.initialize(output)
self.initialized.fill_(1)
if len(output.shape) == 2:
output = output[:,:,None,None]
squeeze = True
else:
squeeze = False
h = output / self.scale - self.loc
if squeeze:
h = h.squeeze(-1).squeeze(-1)
return h
class AbstractEncoder(nn.Module):
def __init__(self):
super().__init__()
def encode(self, *args, **kwargs):
raise NotImplementedError
class Labelator(AbstractEncoder):
"""Net2Net Interface for Class-Conditional Model"""
def __init__(self, n_classes, quantize_interface=True):
super().__init__()
self.n_classes = n_classes
self.quantize_interface = quantize_interface
def encode(self, c):
c = c[:,None]
if self.quantize_interface:
return c, None, [None, None, c.long()]
return c
class SOSProvider(AbstractEncoder):
# for unconditional training
def __init__(self, sos_token, quantize_interface=True):
super().__init__()
self.sos_token = sos_token
self.quantize_interface = quantize_interface
def encode(self, x):
# get batch size from data and replicate sos_token
c = torch.ones(x.shape[0], 1)*self.sos_token
c = c.long().to(x.device)
if self.quantize_interface:
return c, None, [None, None, c]
return c
| 3,847 | 28.374046 | 85 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/taming/modules/vqvae/quantize.py | import torch
import torch.nn as nn
import torch.nn.functional as F
import numpy as np
from torch import einsum
from einops import rearrange
class VectorQuantizer(nn.Module):
"""
see https://github.com/MishaLaskin/vqvae/blob/d761a999e2267766400dc646d82d3ac3657771d4/models/quantizer.py
____________________________________________
Discretization bottleneck part of the VQ-VAE.
Inputs:
- n_e : number of embeddings
- e_dim : dimension of embedding
- beta : commitment cost used in loss term, beta * ||z_e(x)-sg[e]||^2
_____________________________________________
"""
# NOTE: this class contains a bug regarding beta; see VectorQuantizer2 for
# a fix and use legacy=False to apply that fix. VectorQuantizer2 can be
# used wherever VectorQuantizer has been used before and is additionally
# more efficient.
def __init__(self, n_e, e_dim, beta):
super(VectorQuantizer, self).__init__()
self.n_e = n_e
self.e_dim = e_dim
self.beta = beta
self.embedding = nn.Embedding(self.n_e, self.e_dim)
self.embedding.weight.data.uniform_(-1.0 / self.n_e, 1.0 / self.n_e)
def forward(self, z):
"""
Inputs the output of the encoder network z and maps it to a discrete
one-hot vector that is the index of the closest embedding vector e_j
z (continuous) -> z_q (discrete)
z.shape = (batch, channel, height, width)
quantization pipeline:
1. get encoder input (B,C,H,W)
2. flatten input to (B*H*W,C)
"""
# reshape z -> (batch, height, width, channel) and flatten
z = z.permute(0, 2, 3, 1).contiguous()
z_flattened = z.view(-1, self.e_dim)
# distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z
d = torch.sum(z_flattened ** 2, dim=1, keepdim=True) + \
torch.sum(self.embedding.weight**2, dim=1) - 2 * \
torch.matmul(z_flattened, self.embedding.weight.t())
## could possible replace this here
# #\start...
# find closest encodings
min_encoding_indices = torch.argmin(d, dim=1).unsqueeze(1)
min_encodings = torch.zeros(
min_encoding_indices.shape[0], self.n_e).to(z)
min_encodings.scatter_(1, min_encoding_indices, 1)
# dtype min encodings: torch.float32
# min_encodings shape: torch.Size([2048, 512])
# min_encoding_indices.shape: torch.Size([2048, 1])
# get quantized latent vectors
z_q = torch.matmul(min_encodings, self.embedding.weight).view(z.shape)
#.........\end
# with:
# .........\start
#min_encoding_indices = torch.argmin(d, dim=1)
#z_q = self.embedding(min_encoding_indices)
# ......\end......... (TODO)
# compute loss for embedding
loss = torch.mean((z_q.detach()-z)**2) + self.beta * \
torch.mean((z_q - z.detach()) ** 2)
# preserve gradients
z_q = z + (z_q - z).detach()
# perplexity
e_mean = torch.mean(min_encodings, dim=0)
perplexity = torch.exp(-torch.sum(e_mean * torch.log(e_mean + 1e-10)))
# reshape back to match original input shape
z_q = z_q.permute(0, 3, 1, 2).contiguous()
return z_q, loss, (perplexity, min_encodings, min_encoding_indices)
def get_codebook_entry(self, indices, shape):
# shape specifying (batch, height, width, channel)
# TODO: check for more easy handling with nn.Embedding
min_encodings = torch.zeros(indices.shape[0], self.n_e).to(indices)
min_encodings.scatter_(1, indices[:,None], 1)
# get quantized latent vectors
z_q = torch.matmul(min_encodings.float(), self.embedding.weight)
if shape is not None:
z_q = z_q.view(shape)
# reshape back to match original input shape
z_q = z_q.permute(0, 3, 1, 2).contiguous()
return z_q
class GumbelQuantize(nn.Module):
"""
credit to @karpathy: https://github.com/karpathy/deep-vector-quantization/blob/main/model.py (thanks!)
Gumbel Softmax trick quantizer
Categorical Reparameterization with Gumbel-Softmax, Jang et al. 2016
https://arxiv.org/abs/1611.01144
"""
def __init__(self, num_hiddens, embedding_dim, n_embed, straight_through=True,
kl_weight=5e-4, temp_init=1.0, use_vqinterface=True,
remap=None, unknown_index="random"):
super().__init__()
self.embedding_dim = embedding_dim
self.n_embed = n_embed
self.straight_through = straight_through
self.temperature = temp_init
self.kl_weight = kl_weight
self.proj = nn.Conv2d(num_hiddens, n_embed, 1)
self.embed = nn.Embedding(n_embed, embedding_dim)
self.use_vqinterface = use_vqinterface
self.remap = remap
if self.remap is not None:
self.register_buffer("used", torch.tensor(np.load(self.remap)))
self.re_embed = self.used.shape[0]
self.unknown_index = unknown_index # "random" or "extra" or integer
if self.unknown_index == "extra":
self.unknown_index = self.re_embed
self.re_embed = self.re_embed+1
print(f"Remapping {self.n_embed} indices to {self.re_embed} indices. "
f"Using {self.unknown_index} for unknown indices.")
else:
self.re_embed = n_embed
def remap_to_used(self, inds):
ishape = inds.shape
assert len(ishape)>1
inds = inds.reshape(ishape[0],-1)
used = self.used.to(inds)
match = (inds[:,:,None]==used[None,None,...]).long()
new = match.argmax(-1)
unknown = match.sum(2)<1
if self.unknown_index == "random":
new[unknown]=torch.randint(0,self.re_embed,size=new[unknown].shape).to(device=new.device)
else:
new[unknown] = self.unknown_index
return new.reshape(ishape)
def unmap_to_all(self, inds):
ishape = inds.shape
assert len(ishape)>1
inds = inds.reshape(ishape[0],-1)
used = self.used.to(inds)
if self.re_embed > self.used.shape[0]: # extra token
inds[inds>=self.used.shape[0]] = 0 # simply set to zero
back=torch.gather(used[None,:][inds.shape[0]*[0],:], 1, inds)
return back.reshape(ishape)
def forward(self, z, temp=None, return_logits=False):
# force hard = True when we are in eval mode, as we must quantize. actually, always true seems to work
hard = self.straight_through if self.training else True
temp = self.temperature if temp is None else temp
logits = self.proj(z)
if self.remap is not None:
# continue only with used logits
full_zeros = torch.zeros_like(logits)
logits = logits[:,self.used,...]
soft_one_hot = F.gumbel_softmax(logits, tau=temp, dim=1, hard=hard)
if self.remap is not None:
# go back to all entries but unused set to zero
full_zeros[:,self.used,...] = soft_one_hot
soft_one_hot = full_zeros
z_q = einsum('b n h w, n d -> b d h w', soft_one_hot, self.embed.weight)
# + kl divergence to the prior loss
qy = F.softmax(logits, dim=1)
diff = self.kl_weight * torch.sum(qy * torch.log(qy * self.n_embed + 1e-10), dim=1).mean()
ind = soft_one_hot.argmax(dim=1)
if self.remap is not None:
ind = self.remap_to_used(ind)
if self.use_vqinterface:
if return_logits:
return z_q, diff, (None, None, ind), logits
return z_q, diff, (None, None, ind)
return z_q, diff, ind
def get_codebook_entry(self, indices, shape):
b, h, w, c = shape
assert b*h*w == indices.shape[0]
indices = rearrange(indices, '(b h w) -> b h w', b=b, h=h, w=w)
if self.remap is not None:
indices = self.unmap_to_all(indices)
one_hot = F.one_hot(indices, num_classes=self.n_embed).permute(0, 3, 1, 2).float()
z_q = einsum('b n h w, n d -> b d h w', one_hot, self.embed.weight)
return z_q
class VectorQuantizer2(nn.Module):
"""
Improved version over VectorQuantizer, can be used as a drop-in replacement. Mostly
avoids costly matrix multiplications and allows for post-hoc remapping of indices.
"""
# NOTE: due to a bug the beta term was applied to the wrong term. for
# backwards compatibility we use the buggy version by default, but you can
# specify legacy=False to fix it.
def __init__(self, n_e, e_dim, beta, remap=None, unknown_index="random",
sane_index_shape=False, legacy=True):
super().__init__()
self.n_e = n_e
self.e_dim = e_dim
self.beta = beta
self.legacy = legacy
self.embedding = nn.Embedding(self.n_e, self.e_dim)
self.embedding.weight.data.uniform_(-1.0 / self.n_e, 1.0 / self.n_e)
self.remap = remap
if self.remap is not None:
self.register_buffer("used", torch.tensor(np.load(self.remap)))
self.re_embed = self.used.shape[0]
self.unknown_index = unknown_index # "random" or "extra" or integer
if self.unknown_index == "extra":
self.unknown_index = self.re_embed
self.re_embed = self.re_embed+1
print(f"Remapping {self.n_e} indices to {self.re_embed} indices. "
f"Using {self.unknown_index} for unknown indices.")
else:
self.re_embed = n_e
self.sane_index_shape = sane_index_shape
def remap_to_used(self, inds):
ishape = inds.shape
assert len(ishape)>1
inds = inds.reshape(ishape[0],-1)
used = self.used.to(inds)
match = (inds[:,:,None]==used[None,None,...]).long()
new = match.argmax(-1)
unknown = match.sum(2)<1
if self.unknown_index == "random":
new[unknown]=torch.randint(0,self.re_embed,size=new[unknown].shape).to(device=new.device)
else:
new[unknown] = self.unknown_index
return new.reshape(ishape)
def unmap_to_all(self, inds):
ishape = inds.shape
assert len(ishape)>1
inds = inds.reshape(ishape[0],-1)
used = self.used.to(inds)
if self.re_embed > self.used.shape[0]: # extra token
inds[inds>=self.used.shape[0]] = 0 # simply set to zero
back=torch.gather(used[None,:][inds.shape[0]*[0],:], 1, inds)
return back.reshape(ishape)
def forward(self, z, temp=None, rescale_logits=False, return_logits=False):
assert temp is None or temp==1.0, "Only for interface compatible with Gumbel"
assert rescale_logits==False, "Only for interface compatible with Gumbel"
assert return_logits==False, "Only for interface compatible with Gumbel"
# reshape z -> (batch, height, width, channel) and flatten
z = rearrange(z, 'b c h w -> b h w c').contiguous()
z_flattened = z.view(-1, self.e_dim)
# distances from z to embeddings e_j (z - e)^2 = z^2 + e^2 - 2 e * z
d = torch.sum(z_flattened ** 2, dim=1, keepdim=True) + \
torch.sum(self.embedding.weight**2, dim=1) - 2 * \
torch.einsum('bd,dn->bn', z_flattened, rearrange(self.embedding.weight, 'n d -> d n'))
min_encoding_indices = torch.argmin(d, dim=1)
z_q = self.embedding(min_encoding_indices).view(z.shape)
perplexity = None
min_encodings = None
# compute loss for embedding
if not self.legacy:
loss = self.beta * torch.mean((z_q.detach()-z)**2) + \
torch.mean((z_q - z.detach()) ** 2)
else:
loss = torch.mean((z_q.detach()-z)**2) + self.beta * \
torch.mean((z_q - z.detach()) ** 2)
# preserve gradients
z_q = z + (z_q - z).detach()
# reshape back to match original input shape
z_q = rearrange(z_q, 'b h w c -> b c h w').contiguous()
if self.remap is not None:
min_encoding_indices = min_encoding_indices.reshape(z.shape[0],-1) # add batch axis
min_encoding_indices = self.remap_to_used(min_encoding_indices)
min_encoding_indices = min_encoding_indices.reshape(-1,1) # flatten
if self.sane_index_shape:
min_encoding_indices = min_encoding_indices.reshape(
z_q.shape[0], z_q.shape[2], z_q.shape[3])
return z_q, loss, (perplexity, min_encodings, min_encoding_indices)
def get_codebook_entry(self, indices, shape):
# shape specifying (batch, height, width, channel)
if self.remap is not None:
indices = indices.reshape(shape[0],-1) # add batch axis
indices = self.unmap_to_all(indices)
indices = indices.reshape(-1) # flatten again
# get quantized latent vectors
z_q = self.embedding(indices)
if shape is not None:
z_q = z_q.view(shape)
# reshape back to match original input shape
z_q = z_q.permute(0, 3, 1, 2).contiguous()
return z_q
| 13,259 | 39.181818 | 110 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/taming/modules/discriminator/model.py | import functools
import torch.nn as nn
from image_synthesis.taming.modules.util import ActNorm
def weights_init(m):
classname = m.__class__.__name__
if classname.find('Conv') != -1:
nn.init.normal_(m.weight.data, 0.0, 0.02)
elif classname.find('BatchNorm') != -1:
nn.init.normal_(m.weight.data, 1.0, 0.02)
nn.init.constant_(m.bias.data, 0)
class NLayerDiscriminator(nn.Module):
"""Defines a PatchGAN discriminator as in Pix2Pix
--> see https://github.com/junyanz/pytorch-CycleGAN-and-pix2pix/blob/master/models/networks.py
"""
def __init__(self, input_nc=3, ndf=64, n_layers=3, use_actnorm=False):
"""Construct a PatchGAN discriminator
Parameters:
input_nc (int) -- the number of channels in input images
ndf (int) -- the number of filters in the last conv layer
n_layers (int) -- the number of conv layers in the discriminator
norm_layer -- normalization layer
"""
super(NLayerDiscriminator, self).__init__()
if not use_actnorm:
norm_layer = nn.BatchNorm2d
else:
norm_layer = ActNorm
if type(norm_layer) == functools.partial: # no need to use bias as BatchNorm2d has affine parameters
use_bias = norm_layer.func != nn.BatchNorm2d
else:
use_bias = norm_layer != nn.BatchNorm2d
kw = 4
padw = 1
sequence = [nn.Conv2d(input_nc, ndf, kernel_size=kw, stride=2, padding=padw), nn.LeakyReLU(0.2, True)]
nf_mult = 1
nf_mult_prev = 1
for n in range(1, n_layers): # gradually increase the number of filters
nf_mult_prev = nf_mult
nf_mult = min(2 ** n, 8)
sequence += [
nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=2, padding=padw, bias=use_bias),
norm_layer(ndf * nf_mult),
nn.LeakyReLU(0.2, True)
]
nf_mult_prev = nf_mult
nf_mult = min(2 ** n_layers, 8)
sequence += [
nn.Conv2d(ndf * nf_mult_prev, ndf * nf_mult, kernel_size=kw, stride=1, padding=padw, bias=use_bias),
norm_layer(ndf * nf_mult),
nn.LeakyReLU(0.2, True)
]
sequence += [
nn.Conv2d(ndf * nf_mult, 1, kernel_size=kw, stride=1, padding=padw)] # output 1 channel prediction map
self.main = nn.Sequential(*sequence)
def forward(self, input):
"""Standard forward."""
return self.main(input)
| 2,566 | 36.75 | 116 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/taming/modules/misc/coord.py | import torch
class CoordStage(object):
def __init__(self, n_embed, down_factor):
self.n_embed = n_embed
self.down_factor = down_factor
def eval(self):
return self
def encode(self, c):
"""fake vqmodel interface"""
assert 0.0 <= c.min() and c.max() <= 1.0
b,ch,h,w = c.shape
assert ch == 1
c = torch.nn.functional.interpolate(c, scale_factor=1/self.down_factor,
mode="area")
c = c.clamp(0.0, 1.0)
c = self.n_embed*c
c_quant = c.round()
c_ind = c_quant.to(dtype=torch.long)
info = None, None, c_ind
return c_quant, None, info
def decode(self, c):
c = c/self.n_embed
c = torch.nn.functional.interpolate(c, scale_factor=self.down_factor,
mode="nearest")
return c
| 904 | 27.28125 | 79 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/taming/modules/diffusionmodules/model.py | # pytorch_diffusion + derived encoder decoder
import math
import torch
import torch.nn as nn
import numpy as np
def get_timestep_embedding(timesteps, embedding_dim):
"""
This matches the implementation in Denoising Diffusion Probabilistic Models:
From Fairseq.
Build sinusoidal embeddings.
This matches the implementation in tensor2tensor, but differs slightly
from the description in Section 3.5 of "Attention Is All You Need".
"""
assert len(timesteps.shape) == 1
half_dim = embedding_dim // 2
emb = math.log(10000) / (half_dim - 1)
emb = torch.exp(torch.arange(half_dim, dtype=torch.float32) * -emb)
emb = emb.to(device=timesteps.device)
emb = timesteps.float()[:, None] * emb[None, :]
emb = torch.cat([torch.sin(emb), torch.cos(emb)], dim=1)
if embedding_dim % 2 == 1: # zero pad
emb = torch.nn.functional.pad(emb, (0,1,0,0))
return emb
def nonlinearity(x):
# swish
return x*torch.sigmoid(x)
def Normalize(in_channels):
return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
class Upsample(nn.Module):
def __init__(self, in_channels, with_conv):
super().__init__()
self.with_conv = with_conv
if self.with_conv:
self.conv = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=1,
padding=1)
def forward(self, x):
x = torch.nn.functional.interpolate(x, scale_factor=2.0, mode="nearest")
if self.with_conv:
x = self.conv(x)
return x
class Downsample(nn.Module):
def __init__(self, in_channels, with_conv):
super().__init__()
self.with_conv = with_conv
if self.with_conv:
# no asymmetric padding in torch conv, must do it ourselves
self.conv = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=3,
stride=2,
padding=0)
def forward(self, x):
if self.with_conv:
pad = (0,1,0,1)
x = torch.nn.functional.pad(x, pad, mode="constant", value=0)
x = self.conv(x)
else:
x = torch.nn.functional.avg_pool2d(x, kernel_size=2, stride=2)
return x
class ResnetBlock(nn.Module):
def __init__(self, *, in_channels, out_channels=None, conv_shortcut=False,
dropout, temb_channels=512):
super().__init__()
self.in_channels = in_channels
out_channels = in_channels if out_channels is None else out_channels
self.out_channels = out_channels
self.use_conv_shortcut = conv_shortcut
self.norm1 = Normalize(in_channels)
self.conv1 = torch.nn.Conv2d(in_channels,
out_channels,
kernel_size=3,
stride=1,
padding=1)
if temb_channels > 0:
self.temb_proj = torch.nn.Linear(temb_channels,
out_channels)
self.norm2 = Normalize(out_channels)
self.dropout = torch.nn.Dropout(dropout)
self.conv2 = torch.nn.Conv2d(out_channels,
out_channels,
kernel_size=3,
stride=1,
padding=1)
if self.in_channels != self.out_channels:
if self.use_conv_shortcut:
self.conv_shortcut = torch.nn.Conv2d(in_channels,
out_channels,
kernel_size=3,
stride=1,
padding=1)
else:
self.nin_shortcut = torch.nn.Conv2d(in_channels,
out_channels,
kernel_size=1,
stride=1,
padding=0)
def forward(self, x, temb):
h = x
h = self.norm1(h)
h = nonlinearity(h)
h = self.conv1(h)
if temb is not None:
h = h + self.temb_proj(nonlinearity(temb))[:,:,None,None]
h = self.norm2(h)
h = nonlinearity(h)
h = self.dropout(h)
h = self.conv2(h)
if self.in_channels != self.out_channels:
if self.use_conv_shortcut:
x = self.conv_shortcut(x)
else:
x = self.nin_shortcut(x)
return x+h
class AttnBlock(nn.Module):
def __init__(self, in_channels):
super().__init__()
self.in_channels = in_channels
self.norm = Normalize(in_channels)
self.q = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=1,
stride=1,
padding=0)
self.k = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=1,
stride=1,
padding=0)
self.v = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=1,
stride=1,
padding=0)
self.proj_out = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=1,
stride=1,
padding=0)
def forward(self, x):
h_ = x
h_ = self.norm(h_)
q = self.q(h_)
k = self.k(h_)
v = self.v(h_)
# compute attention
b,c,h,w = q.shape
q = q.reshape(b,c,h*w)
q = q.permute(0,2,1) # b,hw,c
k = k.reshape(b,c,h*w) # b,c,hw
w_ = torch.bmm(q,k) # b,hw,hw w[b,i,j]=sum_c q[b,i,c]k[b,c,j]
w_ = w_ * (int(c)**(-0.5))
w_ = torch.nn.functional.softmax(w_, dim=2)
# attend to values
v = v.reshape(b,c,h*w)
w_ = w_.permute(0,2,1) # b,hw,hw (first hw of k, second of q)
h_ = torch.bmm(v,w_) # b, c,hw (hw of q) h_[b,c,j] = sum_i v[b,c,i] w_[b,i,j]
h_ = h_.reshape(b,c,h,w)
h_ = self.proj_out(h_)
return x+h_
class Model(nn.Module):
def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks,
attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels,
resolution, use_timestep=True):
super().__init__()
self.ch = ch
self.temb_ch = self.ch*4
self.num_resolutions = len(ch_mult)
self.num_res_blocks = num_res_blocks
self.resolution = resolution
self.in_channels = in_channels
self.use_timestep = use_timestep
if self.use_timestep:
# timestep embedding
self.temb = nn.Module()
self.temb.dense = nn.ModuleList([
torch.nn.Linear(self.ch,
self.temb_ch),
torch.nn.Linear(self.temb_ch,
self.temb_ch),
])
# downsampling
self.conv_in = torch.nn.Conv2d(in_channels,
self.ch,
kernel_size=3,
stride=1,
padding=1)
curr_res = resolution
in_ch_mult = (1,)+tuple(ch_mult)
self.down = nn.ModuleList()
for i_level in range(self.num_resolutions):
block = nn.ModuleList()
attn = nn.ModuleList()
block_in = ch*in_ch_mult[i_level]
block_out = ch*ch_mult[i_level]
for i_block in range(self.num_res_blocks):
block.append(ResnetBlock(in_channels=block_in,
out_channels=block_out,
temb_channels=self.temb_ch,
dropout=dropout))
block_in = block_out
if curr_res in attn_resolutions:
attn.append(AttnBlock(block_in))
down = nn.Module()
down.block = block
down.attn = attn
if i_level != self.num_resolutions-1:
down.downsample = Downsample(block_in, resamp_with_conv)
curr_res = curr_res // 2
self.down.append(down)
# middle
self.mid = nn.Module()
self.mid.block_1 = ResnetBlock(in_channels=block_in,
out_channels=block_in,
temb_channels=self.temb_ch,
dropout=dropout)
self.mid.attn_1 = AttnBlock(block_in)
self.mid.block_2 = ResnetBlock(in_channels=block_in,
out_channels=block_in,
temb_channels=self.temb_ch,
dropout=dropout)
# upsampling
self.up = nn.ModuleList()
for i_level in reversed(range(self.num_resolutions)):
block = nn.ModuleList()
attn = nn.ModuleList()
block_out = ch*ch_mult[i_level]
skip_in = ch*ch_mult[i_level]
for i_block in range(self.num_res_blocks+1):
if i_block == self.num_res_blocks:
skip_in = ch*in_ch_mult[i_level]
block.append(ResnetBlock(in_channels=block_in+skip_in,
out_channels=block_out,
temb_channels=self.temb_ch,
dropout=dropout))
block_in = block_out
if curr_res in attn_resolutions:
attn.append(AttnBlock(block_in))
up = nn.Module()
up.block = block
up.attn = attn
if i_level != 0:
up.upsample = Upsample(block_in, resamp_with_conv)
curr_res = curr_res * 2
self.up.insert(0, up) # prepend to get consistent order
# end
self.norm_out = Normalize(block_in)
self.conv_out = torch.nn.Conv2d(block_in,
out_ch,
kernel_size=3,
stride=1,
padding=1)
def forward(self, x, t=None):
#assert x.shape[2] == x.shape[3] == self.resolution
if self.use_timestep:
# timestep embedding
assert t is not None
temb = get_timestep_embedding(t, self.ch)
temb = self.temb.dense[0](temb)
temb = nonlinearity(temb)
temb = self.temb.dense[1](temb)
else:
temb = None
# downsampling
hs = [self.conv_in(x)]
for i_level in range(self.num_resolutions):
for i_block in range(self.num_res_blocks):
h = self.down[i_level].block[i_block](hs[-1], temb)
if len(self.down[i_level].attn) > 0:
h = self.down[i_level].attn[i_block](h)
hs.append(h)
if i_level != self.num_resolutions-1:
hs.append(self.down[i_level].downsample(hs[-1]))
# middle
h = hs[-1]
h = self.mid.block_1(h, temb)
h = self.mid.attn_1(h)
h = self.mid.block_2(h, temb)
# upsampling
for i_level in reversed(range(self.num_resolutions)):
for i_block in range(self.num_res_blocks+1):
h = self.up[i_level].block[i_block](
torch.cat([h, hs.pop()], dim=1), temb)
if len(self.up[i_level].attn) > 0:
h = self.up[i_level].attn[i_block](h)
if i_level != 0:
h = self.up[i_level].upsample(h)
# end
h = self.norm_out(h)
h = nonlinearity(h)
h = self.conv_out(h)
return h
class Encoder(nn.Module):
def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks,
attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels,
resolution, z_channels, double_z=True, **ignore_kwargs):
super().__init__()
self.ch = ch
self.temb_ch = 0
self.num_resolutions = len(ch_mult)
self.num_res_blocks = num_res_blocks
self.resolution = resolution
self.in_channels = in_channels
# downsampling
self.conv_in = torch.nn.Conv2d(in_channels,
self.ch,
kernel_size=3,
stride=1,
padding=1)
curr_res = resolution
in_ch_mult = (1,)+tuple(ch_mult)
self.down = nn.ModuleList()
for i_level in range(self.num_resolutions):
block = nn.ModuleList()
attn = nn.ModuleList()
block_in = ch*in_ch_mult[i_level]
block_out = ch*ch_mult[i_level]
for i_block in range(self.num_res_blocks):
block.append(ResnetBlock(in_channels=block_in,
out_channels=block_out,
temb_channels=self.temb_ch,
dropout=dropout))
block_in = block_out
if curr_res in attn_resolutions:
attn.append(AttnBlock(block_in))
down = nn.Module()
down.block = block
down.attn = attn
if i_level != self.num_resolutions-1:
down.downsample = Downsample(block_in, resamp_with_conv)
curr_res = curr_res // 2
self.down.append(down)
# middle
self.mid = nn.Module()
self.mid.block_1 = ResnetBlock(in_channels=block_in,
out_channels=block_in,
temb_channels=self.temb_ch,
dropout=dropout)
self.mid.attn_1 = AttnBlock(block_in)
self.mid.block_2 = ResnetBlock(in_channels=block_in,
out_channels=block_in,
temb_channels=self.temb_ch,
dropout=dropout)
# end
self.norm_out = Normalize(block_in)
self.conv_out = torch.nn.Conv2d(block_in,
2*z_channels if double_z else z_channels,
kernel_size=3,
stride=1,
padding=1)
def forward(self, x):
#assert x.shape[2] == x.shape[3] == self.resolution, "{}, {}, {}".format(x.shape[2], x.shape[3], self.resolution)
# timestep embedding
temb = None
# downsampling
hs = [self.conv_in(x)]
for i_level in range(self.num_resolutions):
for i_block in range(self.num_res_blocks):
h = self.down[i_level].block[i_block](hs[-1], temb)
if len(self.down[i_level].attn) > 0:
h = self.down[i_level].attn[i_block](h)
hs.append(h)
if i_level != self.num_resolutions-1:
hs.append(self.down[i_level].downsample(hs[-1]))
# middle
h = hs[-1]
h = self.mid.block_1(h, temb)
h = self.mid.attn_1(h)
h = self.mid.block_2(h, temb)
# end
h = self.norm_out(h)
h = nonlinearity(h)
h = self.conv_out(h)
return h
class Decoder(nn.Module):
def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks,
attn_resolutions, dropout=0.0, resamp_with_conv=True, in_channels,
resolution, z_channels, give_pre_end=False, **ignorekwargs):
super().__init__()
self.ch = ch
self.temb_ch = 0
self.num_resolutions = len(ch_mult)
self.num_res_blocks = num_res_blocks
self.resolution = resolution
self.in_channels = in_channels
self.give_pre_end = give_pre_end
# compute in_ch_mult, block_in and curr_res at lowest res
in_ch_mult = (1,)+tuple(ch_mult)
block_in = ch*ch_mult[self.num_resolutions-1]
curr_res = resolution // 2**(self.num_resolutions-1)
self.z_shape = (1,z_channels,curr_res,curr_res)
print("Working with z of shape {} = {} dimensions.".format(
self.z_shape, np.prod(self.z_shape)))
# z to block_in
self.conv_in = torch.nn.Conv2d(z_channels,
block_in,
kernel_size=3,
stride=1,
padding=1)
# middle
self.mid = nn.Module()
self.mid.block_1 = ResnetBlock(in_channels=block_in,
out_channels=block_in,
temb_channels=self.temb_ch,
dropout=dropout)
self.mid.attn_1 = AttnBlock(block_in)
self.mid.block_2 = ResnetBlock(in_channels=block_in,
out_channels=block_in,
temb_channels=self.temb_ch,
dropout=dropout)
# upsampling
self.up = nn.ModuleList()
for i_level in reversed(range(self.num_resolutions)):
block = nn.ModuleList()
attn = nn.ModuleList()
block_out = ch*ch_mult[i_level]
for i_block in range(self.num_res_blocks+1):
block.append(ResnetBlock(in_channels=block_in,
out_channels=block_out,
temb_channels=self.temb_ch,
dropout=dropout))
block_in = block_out
if curr_res in attn_resolutions:
attn.append(AttnBlock(block_in))
up = nn.Module()
up.block = block
up.attn = attn
if i_level != 0:
up.upsample = Upsample(block_in, resamp_with_conv)
curr_res = curr_res * 2
self.up.insert(0, up) # prepend to get consistent order
# end
self.norm_out = Normalize(block_in)
self.conv_out = torch.nn.Conv2d(block_in,
out_ch,
kernel_size=3,
stride=1,
padding=1)
def forward(self, z):
#assert z.shape[1:] == self.z_shape[1:]
self.last_z_shape = z.shape
# timestep embedding
temb = None
# z to block_in
h = self.conv_in(z)
# middle
h = self.mid.block_1(h, temb)
h = self.mid.attn_1(h)
h = self.mid.block_2(h, temb)
# upsampling
for i_level in reversed(range(self.num_resolutions)):
for i_block in range(self.num_res_blocks+1):
h = self.up[i_level].block[i_block](h, temb)
if len(self.up[i_level].attn) > 0:
h = self.up[i_level].attn[i_block](h)
if i_level != 0:
h = self.up[i_level].upsample(h)
# end
if self.give_pre_end:
return h
h = self.norm_out(h)
h = nonlinearity(h)
h = self.conv_out(h)
return h
class VUNet(nn.Module):
def __init__(self, *, ch, out_ch, ch_mult=(1,2,4,8), num_res_blocks,
attn_resolutions, dropout=0.0, resamp_with_conv=True,
in_channels, c_channels,
resolution, z_channels, use_timestep=False, **ignore_kwargs):
super().__init__()
self.ch = ch
self.temb_ch = self.ch*4
self.num_resolutions = len(ch_mult)
self.num_res_blocks = num_res_blocks
self.resolution = resolution
self.use_timestep = use_timestep
if self.use_timestep:
# timestep embedding
self.temb = nn.Module()
self.temb.dense = nn.ModuleList([
torch.nn.Linear(self.ch,
self.temb_ch),
torch.nn.Linear(self.temb_ch,
self.temb_ch),
])
# downsampling
self.conv_in = torch.nn.Conv2d(c_channels,
self.ch,
kernel_size=3,
stride=1,
padding=1)
curr_res = resolution
in_ch_mult = (1,)+tuple(ch_mult)
self.down = nn.ModuleList()
for i_level in range(self.num_resolutions):
block = nn.ModuleList()
attn = nn.ModuleList()
block_in = ch*in_ch_mult[i_level]
block_out = ch*ch_mult[i_level]
for i_block in range(self.num_res_blocks):
block.append(ResnetBlock(in_channels=block_in,
out_channels=block_out,
temb_channels=self.temb_ch,
dropout=dropout))
block_in = block_out
if curr_res in attn_resolutions:
attn.append(AttnBlock(block_in))
down = nn.Module()
down.block = block
down.attn = attn
if i_level != self.num_resolutions-1:
down.downsample = Downsample(block_in, resamp_with_conv)
curr_res = curr_res // 2
self.down.append(down)
self.z_in = torch.nn.Conv2d(z_channels,
block_in,
kernel_size=1,
stride=1,
padding=0)
# middle
self.mid = nn.Module()
self.mid.block_1 = ResnetBlock(in_channels=2*block_in,
out_channels=block_in,
temb_channels=self.temb_ch,
dropout=dropout)
self.mid.attn_1 = AttnBlock(block_in)
self.mid.block_2 = ResnetBlock(in_channels=block_in,
out_channels=block_in,
temb_channels=self.temb_ch,
dropout=dropout)
# upsampling
self.up = nn.ModuleList()
for i_level in reversed(range(self.num_resolutions)):
block = nn.ModuleList()
attn = nn.ModuleList()
block_out = ch*ch_mult[i_level]
skip_in = ch*ch_mult[i_level]
for i_block in range(self.num_res_blocks+1):
if i_block == self.num_res_blocks:
skip_in = ch*in_ch_mult[i_level]
block.append(ResnetBlock(in_channels=block_in+skip_in,
out_channels=block_out,
temb_channels=self.temb_ch,
dropout=dropout))
block_in = block_out
if curr_res in attn_resolutions:
attn.append(AttnBlock(block_in))
up = nn.Module()
up.block = block
up.attn = attn
if i_level != 0:
up.upsample = Upsample(block_in, resamp_with_conv)
curr_res = curr_res * 2
self.up.insert(0, up) # prepend to get consistent order
# end
self.norm_out = Normalize(block_in)
self.conv_out = torch.nn.Conv2d(block_in,
out_ch,
kernel_size=3,
stride=1,
padding=1)
def forward(self, x, z):
#assert x.shape[2] == x.shape[3] == self.resolution
if self.use_timestep:
# timestep embedding
assert t is not None
temb = get_timestep_embedding(t, self.ch)
temb = self.temb.dense[0](temb)
temb = nonlinearity(temb)
temb = self.temb.dense[1](temb)
else:
temb = None
# downsampling
hs = [self.conv_in(x)]
for i_level in range(self.num_resolutions):
for i_block in range(self.num_res_blocks):
h = self.down[i_level].block[i_block](hs[-1], temb)
if len(self.down[i_level].attn) > 0:
h = self.down[i_level].attn[i_block](h)
hs.append(h)
if i_level != self.num_resolutions-1:
hs.append(self.down[i_level].downsample(hs[-1]))
# middle
h = hs[-1]
z = self.z_in(z)
h = torch.cat((h,z),dim=1)
h = self.mid.block_1(h, temb)
h = self.mid.attn_1(h)
h = self.mid.block_2(h, temb)
# upsampling
for i_level in reversed(range(self.num_resolutions)):
for i_block in range(self.num_res_blocks+1):
h = self.up[i_level].block[i_block](
torch.cat([h, hs.pop()], dim=1), temb)
if len(self.up[i_level].attn) > 0:
h = self.up[i_level].attn[i_block](h)
if i_level != 0:
h = self.up[i_level].upsample(h)
# end
h = self.norm_out(h)
h = nonlinearity(h)
h = self.conv_out(h)
return h
class SimpleDecoder(nn.Module):
def __init__(self, in_channels, out_channels, *args, **kwargs):
super().__init__()
self.model = nn.ModuleList([nn.Conv2d(in_channels, in_channels, 1),
ResnetBlock(in_channels=in_channels,
out_channels=2 * in_channels,
temb_channels=0, dropout=0.0),
ResnetBlock(in_channels=2 * in_channels,
out_channels=4 * in_channels,
temb_channels=0, dropout=0.0),
ResnetBlock(in_channels=4 * in_channels,
out_channels=2 * in_channels,
temb_channels=0, dropout=0.0),
nn.Conv2d(2*in_channels, in_channels, 1),
Upsample(in_channels, with_conv=True)])
# end
self.norm_out = Normalize(in_channels)
self.conv_out = torch.nn.Conv2d(in_channels,
out_channels,
kernel_size=3,
stride=1,
padding=1)
def forward(self, x):
for i, layer in enumerate(self.model):
if i in [1,2,3]:
x = layer(x, None)
else:
x = layer(x)
h = self.norm_out(x)
h = nonlinearity(h)
x = self.conv_out(h)
return x
class UpsampleDecoder(nn.Module):
def __init__(self, in_channels, out_channels, ch, num_res_blocks, resolution,
ch_mult=(2,2), dropout=0.0):
super().__init__()
# upsampling
self.temb_ch = 0
self.num_resolutions = len(ch_mult)
self.num_res_blocks = num_res_blocks
block_in = in_channels
curr_res = resolution // 2 ** (self.num_resolutions - 1)
self.res_blocks = nn.ModuleList()
self.upsample_blocks = nn.ModuleList()
for i_level in range(self.num_resolutions):
res_block = []
block_out = ch * ch_mult[i_level]
for i_block in range(self.num_res_blocks + 1):
res_block.append(ResnetBlock(in_channels=block_in,
out_channels=block_out,
temb_channels=self.temb_ch,
dropout=dropout))
block_in = block_out
self.res_blocks.append(nn.ModuleList(res_block))
if i_level != self.num_resolutions - 1:
self.upsample_blocks.append(Upsample(block_in, True))
curr_res = curr_res * 2
# end
self.norm_out = Normalize(block_in)
self.conv_out = torch.nn.Conv2d(block_in,
out_channels,
kernel_size=3,
stride=1,
padding=1)
def forward(self, x):
# upsampling
h = x
for k, i_level in enumerate(range(self.num_resolutions)):
for i_block in range(self.num_res_blocks + 1):
h = self.res_blocks[i_level][i_block](h, None)
if i_level != self.num_resolutions - 1:
h = self.upsample_blocks[k](h)
h = self.norm_out(h)
h = nonlinearity(h)
h = self.conv_out(h)
return h
| 30,221 | 37.895753 | 121 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/taming/modules/transformer/mingpt.py | """
taken from: https://github.com/karpathy/minGPT/
GPT model:
- the initial stem consists of a combination of token encoding and a positional encoding
- the meat of it is a uniform sequence of Transformer blocks
- each Transformer is a sequential combination of a 1-hidden-layer MLP block and a self-attention block
- all blocks feed into a central residual pathway similar to resnets
- the final decoder is a linear projection into a vanilla Softmax classifier
"""
import math
import logging
import torch
import torch.nn as nn
from torch.nn import functional as F
logger = logging.getLogger(__name__)
class GPTConfig:
""" base GPT config, params common to all GPT versions """
embd_pdrop = 0.1
resid_pdrop = 0.1
attn_pdrop = 0.1
def __init__(self, vocab_size, block_size, **kwargs):
self.vocab_size = vocab_size
self.block_size = block_size
for k,v in kwargs.items():
setattr(self, k, v)
class GPT1Config(GPTConfig):
""" GPT-1 like network roughly 125M params """
n_layer = 12
n_head = 12
n_embd = 768
class CausalSelfAttention(nn.Module):
"""
A vanilla multi-head masked self-attention layer with a projection at the end.
It is possible to use torch.nn.MultiheadAttention here but I am including an
explicit implementation here to show that there is nothing too scary here.
"""
def __init__(self, config):
super().__init__()
assert config.n_embd % config.n_head == 0
# key, query, value projections for all heads
self.key = nn.Linear(config.n_embd, config.n_embd)
self.query = nn.Linear(config.n_embd, config.n_embd)
self.value = nn.Linear(config.n_embd, config.n_embd)
# regularization
self.attn_drop = nn.Dropout(config.attn_pdrop)
self.resid_drop = nn.Dropout(config.resid_pdrop)
# output projection
self.proj = nn.Linear(config.n_embd, config.n_embd)
# causal mask to ensure that attention is only applied to the left in the input sequence
mask = torch.tril(torch.ones(config.block_size,
config.block_size))
if hasattr(config, "n_unmasked"):
mask[:config.n_unmasked, :config.n_unmasked] = 1
self.register_buffer("mask", mask.view(1, 1, config.block_size, config.block_size))
self.n_head = config.n_head
def forward(self, x, layer_past=None):
B, T, C = x.size()
# calculate query, key, values for all heads in batch and move head forward to be the batch dim
k = self.key(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
q = self.query(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
v = self.value(x).view(B, T, self.n_head, C // self.n_head).transpose(1, 2) # (B, nh, T, hs)
present = torch.stack((k, v))
if layer_past is not None:
past_key, past_value = layer_past
k = torch.cat((past_key, k), dim=-2)
v = torch.cat((past_value, v), dim=-2)
# causal self-attention; Self-attend: (B, nh, T, hs) x (B, nh, hs, T) -> (B, nh, T, T)
att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1)))
if layer_past is None:
att = att.masked_fill(self.mask[:,:,:T,:T] == 0, float('-inf'))
att = F.softmax(att, dim=-1)
att = self.attn_drop(att)
y = att @ v # (B, nh, T, T) x (B, nh, T, hs) -> (B, nh, T, hs)
y = y.transpose(1, 2).contiguous().view(B, T, C) # re-assemble all head outputs side by side
# output projection
y = self.resid_drop(self.proj(y))
return y, present # TODO: check that this does not break anything
class Block(nn.Module):
""" an unassuming Transformer block """
def __init__(self, config):
super().__init__()
self.ln1 = nn.LayerNorm(config.n_embd)
self.ln2 = nn.LayerNorm(config.n_embd)
self.attn = CausalSelfAttention(config)
self.mlp = nn.Sequential(
nn.Linear(config.n_embd, 4 * config.n_embd),
nn.GELU(), # nice
nn.Linear(4 * config.n_embd, config.n_embd),
nn.Dropout(config.resid_pdrop),
)
def forward(self, x, layer_past=None, return_present=False):
# TODO: check that training still works
if return_present: assert not self.training
# layer past: tuple of length two with B, nh, T, hs
attn, present = self.attn(self.ln1(x), layer_past=layer_past)
x = x + attn
x = x + self.mlp(self.ln2(x))
if layer_past is not None or return_present:
return x, present
return x
class GPT(nn.Module):
""" the full GPT language model, with a context size of block_size """
def __init__(self, vocab_size, block_size, n_layer=12, n_head=8, n_embd=256,
embd_pdrop=0., resid_pdrop=0., attn_pdrop=0., n_unmasked=0):
super().__init__()
config = GPTConfig(vocab_size=vocab_size, block_size=block_size,
embd_pdrop=embd_pdrop, resid_pdrop=resid_pdrop, attn_pdrop=attn_pdrop,
n_layer=n_layer, n_head=n_head, n_embd=n_embd,
n_unmasked=n_unmasked)
# input embedding stem
self.tok_emb = nn.Embedding(config.vocab_size, config.n_embd)
self.pos_emb = nn.Parameter(torch.zeros(1, config.block_size, config.n_embd))
self.drop = nn.Dropout(config.embd_pdrop)
# transformer
self.blocks = nn.Sequential(*[Block(config) for _ in range(config.n_layer)])
# decoder head
self.ln_f = nn.LayerNorm(config.n_embd)
self.head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
self.block_size = config.block_size
self.apply(self._init_weights)
self.config = config
logger.info("number of parameters: %e", sum(p.numel() for p in self.parameters()))
def get_block_size(self):
return self.block_size
def _init_weights(self, module):
if isinstance(module, (nn.Linear, nn.Embedding)):
module.weight.data.normal_(mean=0.0, std=0.02)
if isinstance(module, nn.Linear) and module.bias is not None:
module.bias.data.zero_()
elif isinstance(module, nn.LayerNorm):
module.bias.data.zero_()
module.weight.data.fill_(1.0)
def forward(self, idx, embeddings=None, targets=None):
# forward the GPT model
token_embeddings = self.tok_emb(idx) # each index maps to a (learnable) vector
if embeddings is not None: # prepend explicit embeddings
token_embeddings = torch.cat((embeddings, token_embeddings), dim=1)
t = token_embeddings.shape[1]
assert t <= self.block_size, "Cannot forward, model block size is exhausted."
position_embeddings = self.pos_emb[:, :t, :] # each position maps to a (learnable) vector
x = self.drop(token_embeddings + position_embeddings)
x = self.blocks(x)
x = self.ln_f(x)
logits = self.head(x)
# if we are given some desired targets also calculate the loss
loss = None
if targets is not None:
loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
return logits, loss
def forward_with_past(self, idx, embeddings=None, targets=None, past=None, past_length=None):
# inference only
assert not self.training
token_embeddings = self.tok_emb(idx) # each index maps to a (learnable) vector
if embeddings is not None: # prepend explicit embeddings
token_embeddings = torch.cat((embeddings, token_embeddings), dim=1)
if past is not None:
assert past_length is not None
past = torch.cat(past, dim=-2) # n_layer, 2, b, nh, len_past, dim_head
past_shape = list(past.shape)
expected_shape = [self.config.n_layer, 2, idx.shape[0], self.config.n_head, past_length, self.config.n_embd//self.config.n_head]
assert past_shape == expected_shape, f"{past_shape} =/= {expected_shape}"
position_embeddings = self.pos_emb[:, past_length, :] # each position maps to a (learnable) vector
else:
position_embeddings = self.pos_emb[:, :token_embeddings.shape[1], :]
x = self.drop(token_embeddings + position_embeddings)
presents = [] # accumulate over layers
for i, block in enumerate(self.blocks):
x, present = block(x, layer_past=past[i, ...] if past is not None else None, return_present=True)
presents.append(present)
x = self.ln_f(x)
logits = self.head(x)
# if we are given some desired targets also calculate the loss
loss = None
if targets is not None:
loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
return logits, loss, torch.stack(presents) # _, _, n_layer, 2, b, nh, 1, dim_head
class DummyGPT(nn.Module):
# for debugging
def __init__(self, add_value=1):
super().__init__()
self.add_value = add_value
def forward(self, idx):
return idx + self.add_value, None
class CodeGPT(nn.Module):
"""Takes in semi-embeddings"""
def __init__(self, vocab_size, block_size, in_channels, n_layer=12, n_head=8, n_embd=256,
embd_pdrop=0., resid_pdrop=0., attn_pdrop=0., n_unmasked=0):
super().__init__()
config = GPTConfig(vocab_size=vocab_size, block_size=block_size,
embd_pdrop=embd_pdrop, resid_pdrop=resid_pdrop, attn_pdrop=attn_pdrop,
n_layer=n_layer, n_head=n_head, n_embd=n_embd,
n_unmasked=n_unmasked)
# input embedding stem
self.tok_emb = nn.Linear(in_channels, config.n_embd)
self.pos_emb = nn.Parameter(torch.zeros(1, config.block_size, config.n_embd))
self.drop = nn.Dropout(config.embd_pdrop)
# transformer
self.blocks = nn.Sequential(*[Block(config) for _ in range(config.n_layer)])
# decoder head
self.ln_f = nn.LayerNorm(config.n_embd)
self.head = nn.Linear(config.n_embd, config.vocab_size, bias=False)
self.block_size = config.block_size
self.apply(self._init_weights)
self.config = config
logger.info("number of parameters: %e", sum(p.numel() for p in self.parameters()))
def get_block_size(self):
return self.block_size
def _init_weights(self, module):
if isinstance(module, (nn.Linear, nn.Embedding)):
module.weight.data.normal_(mean=0.0, std=0.02)
if isinstance(module, nn.Linear) and module.bias is not None:
module.bias.data.zero_()
elif isinstance(module, nn.LayerNorm):
module.bias.data.zero_()
module.weight.data.fill_(1.0)
def forward(self, idx, embeddings=None, targets=None):
# forward the GPT model
token_embeddings = self.tok_emb(idx) # each index maps to a (learnable) vector
if embeddings is not None: # prepend explicit embeddings
token_embeddings = torch.cat((embeddings, token_embeddings), dim=1)
t = token_embeddings.shape[1]
assert t <= self.block_size, "Cannot forward, model block size is exhausted."
position_embeddings = self.pos_emb[:, :t, :] # each position maps to a (learnable) vector
x = self.drop(token_embeddings + position_embeddings)
x = self.blocks(x)
x = self.taming_cinln_f(x)
logits = self.head(x)
# if we are given some desired targets also calculate the loss
loss = None
if targets is not None:
loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1))
return logits, loss
#### sampling utils
def top_k_logits(logits, k):
v, ix = torch.topk(logits, k)
out = logits.clone()
out[out < v[:, [-1]]] = -float('Inf')
return out
@torch.no_grad()
def sample(model, x, steps, temperature=1.0, sample=False, top_k=None):
"""
take a conditioning sequence of indices in x (of shape (b,t)) and predict the next token in
the sequence, feeding the predictions back into the model each time. Clearly the sampling
has quadratic complexity unlike an RNN that is only linear, and has a finite context window
of block_size, unlike an RNN that has an infinite context window.
"""
block_size = model.get_block_size()
model.eval()
for k in range(steps):
x_cond = x if x.size(1) <= block_size else x[:, -block_size:] # crop context if needed
logits, _ = model(x_cond)
# pluck the logits at the final step and scale by temperature
logits = logits[:, -1, :] / temperature
# optionally crop probabilities to only the top k options
if top_k is not None:
logits = top_k_logits(logits, top_k)
# apply softmax to convert to probabilities
probs = F.softmax(logits, dim=-1)
# sample from the distribution or take the most likely
if sample:
ix = torch.multinomial(probs, num_samples=1)
else:
_, ix = torch.topk(probs, k=1, dim=-1)
# append to the sequence and continue
x = torch.cat((x, ix), dim=1)
return x
#### clustering utils
class KMeans(nn.Module):
def __init__(self, ncluster=512, nc=3, niter=10):
super().__init__()
self.ncluster = ncluster
self.nc = nc
self.niter = niter
self.shape = (3,32,32)
self.register_buffer("C", torch.zeros(self.ncluster,nc))
self.register_buffer('initialized', torch.tensor(0, dtype=torch.uint8))
def is_initialized(self):
return self.initialized.item() == 1
@torch.no_grad()
def initialize(self, x):
N, D = x.shape
assert D == self.nc, D
c = x[torch.randperm(N)[:self.ncluster]] # init clusters at random
for i in range(self.niter):
# assign all pixels to the closest codebook element
a = ((x[:, None, :] - c[None, :, :])**2).sum(-1).argmin(1)
# move each codebook element to be the mean of the pixels that assigned to it
c = torch.stack([x[a==k].mean(0) for k in range(self.ncluster)])
# re-assign any poorly positioned codebook elements
nanix = torch.any(torch.isnan(c), dim=1)
ndead = nanix.sum().item()
print('done step %d/%d, re-initialized %d dead clusters' % (i+1, self.niter, ndead))
c[nanix] = x[torch.randperm(N)[:ndead]] # re-init dead clusters
self.C.copy_(c)
self.initialized.fill_(1)
def forward(self, x, reverse=False, shape=None):
if not reverse:
# flatten
bs,c,h,w = x.shape
assert c == self.nc
x = x.reshape(bs,c,h*w,1)
C = self.C.permute(1,0)
C = C.reshape(1,c,1,self.ncluster)
a = ((x-C)**2).sum(1).argmin(-1) # bs, h*w indices
return a
else:
# flatten
bs, HW = x.shape
"""
c = self.C.reshape( 1, self.nc, 1, self.ncluster)
c = c[bs*[0],:,:,:]
c = c[:,:,HW*[0],:]
x = x.reshape(bs, 1, HW, 1)
x = x[:,3*[0],:,:]
x = torch.gather(c, dim=3, index=x)
"""
x = self.C[x]
x = x.permute(0,2,1)
shape = shape if shape is not None else self.shape
x = x.reshape(bs, *shape)
return x
| 15,743 | 40.10705 | 140 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/taming/modules/transformer/permuter.py | import torch
import torch.nn as nn
import numpy as np
class AbstractPermuter(nn.Module):
def __init__(self, *args, **kwargs):
super().__init__()
def forward(self, x, reverse=False):
raise NotImplementedError
class Identity(AbstractPermuter):
def __init__(self):
super().__init__()
def forward(self, x, reverse=False):
return x
class Subsample(AbstractPermuter):
def __init__(self, H, W):
super().__init__()
C = 1
indices = np.arange(H*W).reshape(C,H,W)
while min(H, W) > 1:
indices = indices.reshape(C,H//2,2,W//2,2)
indices = indices.transpose(0,2,4,1,3)
indices = indices.reshape(C*4,H//2, W//2)
H = H//2
W = W//2
C = C*4
assert H == W == 1
idx = torch.tensor(indices.ravel())
self.register_buffer('forward_shuffle_idx',
nn.Parameter(idx, requires_grad=False))
self.register_buffer('backward_shuffle_idx',
nn.Parameter(torch.argsort(idx), requires_grad=False))
def forward(self, x, reverse=False):
if not reverse:
return x[:, self.forward_shuffle_idx]
else:
return x[:, self.backward_shuffle_idx]
def mortonify(i, j):
"""(i,j) index to linear morton code"""
i = np.uint64(i)
j = np.uint64(j)
z = np.uint(0)
for pos in range(32):
z = (z |
((j & (np.uint64(1) << np.uint64(pos))) << np.uint64(pos)) |
((i & (np.uint64(1) << np.uint64(pos))) << np.uint64(pos+1))
)
return z
class ZCurve(AbstractPermuter):
def __init__(self, H, W):
super().__init__()
reverseidx = [np.int64(mortonify(i,j)) for i in range(H) for j in range(W)]
idx = np.argsort(reverseidx)
idx = torch.tensor(idx)
reverseidx = torch.tensor(reverseidx)
self.register_buffer('forward_shuffle_idx',
idx)
self.register_buffer('backward_shuffle_idx',
reverseidx)
def forward(self, x, reverse=False):
if not reverse:
return x[:, self.forward_shuffle_idx]
else:
return x[:, self.backward_shuffle_idx]
class SpiralOut(AbstractPermuter):
def __init__(self, H, W):
super().__init__()
assert H == W
size = W
indices = np.arange(size*size).reshape(size,size)
i0 = size//2
j0 = size//2-1
i = i0
j = j0
idx = [indices[i0, j0]]
step_mult = 0
for c in range(1, size//2+1):
step_mult += 1
# steps left
for k in range(step_mult):
i = i - 1
j = j
idx.append(indices[i, j])
# step down
for k in range(step_mult):
i = i
j = j + 1
idx.append(indices[i, j])
step_mult += 1
if c < size//2:
# step right
for k in range(step_mult):
i = i + 1
j = j
idx.append(indices[i, j])
# step up
for k in range(step_mult):
i = i
j = j - 1
idx.append(indices[i, j])
else:
# end reached
for k in range(step_mult-1):
i = i + 1
idx.append(indices[i, j])
assert len(idx) == size*size
idx = torch.tensor(idx)
self.register_buffer('forward_shuffle_idx', idx)
self.register_buffer('backward_shuffle_idx', torch.argsort(idx))
def forward(self, x, reverse=False):
if not reverse:
return x[:, self.forward_shuffle_idx]
else:
return x[:, self.backward_shuffle_idx]
class SpiralIn(AbstractPermuter):
def __init__(self, H, W):
super().__init__()
assert H == W
size = W
indices = np.arange(size*size).reshape(size,size)
i0 = size//2
j0 = size//2-1
i = i0
j = j0
idx = [indices[i0, j0]]
step_mult = 0
for c in range(1, size//2+1):
step_mult += 1
# steps left
for k in range(step_mult):
i = i - 1
j = j
idx.append(indices[i, j])
# step down
for k in range(step_mult):
i = i
j = j + 1
idx.append(indices[i, j])
step_mult += 1
if c < size//2:
# step right
for k in range(step_mult):
i = i + 1
j = j
idx.append(indices[i, j])
# step up
for k in range(step_mult):
i = i
j = j - 1
idx.append(indices[i, j])
else:
# end reached
for k in range(step_mult-1):
i = i + 1
idx.append(indices[i, j])
assert len(idx) == size*size
idx = idx[::-1]
idx = torch.tensor(idx)
self.register_buffer('forward_shuffle_idx', idx)
self.register_buffer('backward_shuffle_idx', torch.argsort(idx))
def forward(self, x, reverse=False):
if not reverse:
return x[:, self.forward_shuffle_idx]
else:
return x[:, self.backward_shuffle_idx]
class Random(nn.Module):
def __init__(self, H, W):
super().__init__()
indices = np.random.RandomState(1).permutation(H*W)
idx = torch.tensor(indices.ravel())
self.register_buffer('forward_shuffle_idx', idx)
self.register_buffer('backward_shuffle_idx', torch.argsort(idx))
def forward(self, x, reverse=False):
if not reverse:
return x[:, self.forward_shuffle_idx]
else:
return x[:, self.backward_shuffle_idx]
class AlternateParsing(AbstractPermuter):
def __init__(self, H, W):
super().__init__()
indices = np.arange(W*H).reshape(H,W)
for i in range(1, H, 2):
indices[i, :] = indices[i, ::-1]
idx = indices.flatten()
assert len(idx) == H*W
idx = torch.tensor(idx)
self.register_buffer('forward_shuffle_idx', idx)
self.register_buffer('backward_shuffle_idx', torch.argsort(idx))
def forward(self, x, reverse=False):
if not reverse:
return x[:, self.forward_shuffle_idx]
else:
return x[:, self.backward_shuffle_idx]
if __name__ == "__main__":
p0 = AlternateParsing(16, 16)
print(p0.forward_shuffle_idx)
print(p0.backward_shuffle_idx)
x = torch.randint(0, 768, size=(11, 256))
y = p0(x)
xre = p0(y, reverse=True)
assert torch.equal(x, xre)
p1 = SpiralOut(2, 2)
print(p1.forward_shuffle_idx)
print(p1.backward_shuffle_idx)
| 7,093 | 27.48996 | 83 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/taming/modules/losses/lpips.py | """Stripped version of https://github.com/richzhang/PerceptualSimilarity/tree/master/models"""
import torch
import torch.nn as nn
from torchvision import models
from collections import namedtuple
from image_synthesis.taming.util import get_ckpt_path
class LPIPS(nn.Module):
# Learned perceptual metric
def __init__(self, use_dropout=True):
super().__init__()
self.scaling_layer = ScalingLayer()
self.chns = [64, 128, 256, 512, 512] # vg16 features
self.net = vgg16(pretrained=True, requires_grad=False)
self.lin0 = NetLinLayer(self.chns[0], use_dropout=use_dropout)
self.lin1 = NetLinLayer(self.chns[1], use_dropout=use_dropout)
self.lin2 = NetLinLayer(self.chns[2], use_dropout=use_dropout)
self.lin3 = NetLinLayer(self.chns[3], use_dropout=use_dropout)
self.lin4 = NetLinLayer(self.chns[4], use_dropout=use_dropout)
self.load_from_pretrained()
for param in self.parameters():
param.requires_grad = False
def load_from_pretrained(self, name="vgg_lpips"):
ckpt = get_ckpt_path(name, "taming/modules/autoencoder/lpips")
self.load_state_dict(torch.load(ckpt, map_location=torch.device("cpu")), strict=False)
print("loaded pretrained LPIPS loss from {}".format(ckpt))
@classmethod
def from_pretrained(cls, name="vgg_lpips"):
model = cls()
ckpt = get_ckpt_path(name)
model.load_state_dict(torch.load(ckpt, map_location=torch.device("cpu")), strict=False)
return model
def forward(self, input, target):
in0_input, in1_input = (self.scaling_layer(input), self.scaling_layer(target))
outs0, outs1 = self.net(in0_input), self.net(in1_input)
feats0, feats1, diffs = {}, {}, {}
lins = [self.lin0, self.lin1, self.lin2, self.lin3, self.lin4]
for kk in range(len(self.chns)):
feats0[kk], feats1[kk] = normalize_tensor(outs0[kk]), normalize_tensor(outs1[kk])
diffs[kk] = (feats0[kk] - feats1[kk]) ** 2
res = [spatial_average(lins[kk].model(diffs[kk]), keepdim=True) for kk in range(len(self.chns))]
val = res[0]
for l in range(1, len(self.chns)):
val += res[l]
return val
class ScalingLayer(nn.Module):
def __init__(self):
super(ScalingLayer, self).__init__()
self.register_buffer('shift', torch.Tensor([-.030, -.088, -.188])[None, :, None, None])
self.register_buffer('scale', torch.Tensor([.458, .448, .450])[None, :, None, None])
def forward(self, inp):
return (inp - self.shift) / self.scale
class NetLinLayer(nn.Module):
""" A single linear layer which does a 1x1 conv """
def __init__(self, chn_in, chn_out=1, use_dropout=False):
super(NetLinLayer, self).__init__()
layers = [nn.Dropout(), ] if (use_dropout) else []
layers += [nn.Conv2d(chn_in, chn_out, 1, stride=1, padding=0, bias=False), ]
self.model = nn.Sequential(*layers)
class vgg16(torch.nn.Module):
def __init__(self, requires_grad=False, pretrained=True):
super(vgg16, self).__init__()
vgg_pretrained_features = models.vgg16(pretrained=pretrained).features
self.slice1 = torch.nn.Sequential()
self.slice2 = torch.nn.Sequential()
self.slice3 = torch.nn.Sequential()
self.slice4 = torch.nn.Sequential()
self.slice5 = torch.nn.Sequential()
self.N_slices = 5
for x in range(4):
self.slice1.add_module(str(x), vgg_pretrained_features[x])
for x in range(4, 9):
self.slice2.add_module(str(x), vgg_pretrained_features[x])
for x in range(9, 16):
self.slice3.add_module(str(x), vgg_pretrained_features[x])
for x in range(16, 23):
self.slice4.add_module(str(x), vgg_pretrained_features[x])
for x in range(23, 30):
self.slice5.add_module(str(x), vgg_pretrained_features[x])
if not requires_grad:
for param in self.parameters():
param.requires_grad = False
def forward(self, X):
h = self.slice1(X)
h_relu1_2 = h
h = self.slice2(h)
h_relu2_2 = h
h = self.slice3(h)
h_relu3_3 = h
h = self.slice4(h)
h_relu4_3 = h
h = self.slice5(h)
h_relu5_3 = h
vgg_outputs = namedtuple("VggOutputs", ['relu1_2', 'relu2_2', 'relu3_3', 'relu4_3', 'relu5_3'])
out = vgg_outputs(h_relu1_2, h_relu2_2, h_relu3_3, h_relu4_3, h_relu5_3)
return out
def normalize_tensor(x,eps=1e-10):
norm_factor = torch.sqrt(torch.sum(x**2,dim=1,keepdim=True))
return x/(norm_factor+eps)
def spatial_average(x, keepdim=True):
return x.mean([2,3],keepdim=keepdim)
| 4,778 | 38.172131 | 104 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/taming/modules/losses/segmentation.py | import torch.nn as nn
import torch.nn.functional as F
class BCELoss(nn.Module):
def forward(self, prediction, target):
loss = F.binary_cross_entropy_with_logits(prediction,target)
return loss, {}
class BCELossWithQuant(nn.Module):
def __init__(self, codebook_weight=1.):
super().__init__()
self.codebook_weight = codebook_weight
def forward(self, qloss, target, prediction, split):
bce_loss = F.binary_cross_entropy_with_logits(prediction,target)
loss = bce_loss + self.codebook_weight*qloss
return loss, {"{}/total_loss".format(split): loss.clone().detach().mean(),
"{}/bce_loss".format(split): bce_loss.detach().mean(),
"{}/quant_loss".format(split): qloss.detach().mean()
}
| 816 | 34.521739 | 82 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/taming/modules/losses/vqperceptual.py | import torch
import torch.nn as nn
import torch.nn.functional as F
from image_synthesis.taming.modules.losses.lpips import LPIPS
from image_synthesis.taming.modules.discriminator.model import NLayerDiscriminator, weights_init
class DummyLoss(nn.Module):
def __init__(self):
super().__init__()
def adopt_weight(weight, global_step, threshold=0, value=0.):
if global_step < threshold:
weight = value
return weight
def hinge_d_loss(logits_real, logits_fake):
loss_real = torch.mean(F.relu(1. - logits_real))
loss_fake = torch.mean(F.relu(1. + logits_fake))
d_loss = 0.5 * (loss_real + loss_fake)
return d_loss
def vanilla_d_loss(logits_real, logits_fake):
d_loss = 0.5 * (
torch.mean(torch.nn.functional.softplus(-logits_real)) +
torch.mean(torch.nn.functional.softplus(logits_fake)))
return d_loss
class VQLPIPSWithDiscriminator(nn.Module):
def __init__(self, disc_start, codebook_weight=1.0, pixelloss_weight=1.0,
disc_num_layers=3, disc_in_channels=3, disc_factor=1.0, disc_weight=1.0,
perceptual_weight=1.0, use_actnorm=False, disc_conditional=False,
disc_ndf=64, disc_loss="hinge"):
super().__init__()
assert disc_loss in ["hinge", "vanilla"]
self.codebook_weight = codebook_weight
self.pixel_weight = pixelloss_weight
self.perceptual_loss = LPIPS().eval()
self.perceptual_weight = perceptual_weight
self.discriminator = NLayerDiscriminator(input_nc=disc_in_channels,
n_layers=disc_num_layers,
use_actnorm=use_actnorm,
ndf=disc_ndf
).apply(weights_init)
self.discriminator_iter_start = disc_start
if disc_loss == "hinge":
self.disc_loss = hinge_d_loss
elif disc_loss == "vanilla":
self.disc_loss = vanilla_d_loss
else:
raise ValueError(f"Unknown GAN loss '{disc_loss}'.")
print(f"VQLPIPSWithDiscriminator running with {disc_loss} loss.")
self.disc_factor = disc_factor
self.discriminator_weight = disc_weight
self.disc_conditional = disc_conditional
def calculate_adaptive_weight(self, nll_loss, g_loss, last_layer=None):
if last_layer is not None:
nll_grads = torch.autograd.grad(nll_loss, last_layer, retain_graph=True)[0]
g_grads = torch.autograd.grad(g_loss, last_layer, retain_graph=True)[0]
else:
nll_grads = torch.autograd.grad(nll_loss, self.last_layer[0], retain_graph=True)[0]
g_grads = torch.autograd.grad(g_loss, self.last_layer[0], retain_graph=True)[0]
d_weight = torch.norm(nll_grads) / (torch.norm(g_grads) + 1e-4)
d_weight = torch.clamp(d_weight, 0.0, 1e4).detach()
d_weight = d_weight * self.discriminator_weight
return d_weight
def forward(self, codebook_loss, inputs, reconstructions, optimizer_idx,
global_step, last_layer=None, cond=None, split="train"):
rec_loss = torch.abs(inputs.contiguous() - reconstructions.contiguous())
if self.perceptual_weight > 0:
p_loss = self.perceptual_loss(inputs.contiguous(), reconstructions.contiguous())
rec_loss = rec_loss + self.perceptual_weight * p_loss
else:
p_loss = torch.tensor([0.0])
nll_loss = rec_loss
#nll_loss = torch.sum(nll_loss) / nll_loss.shape[0]
nll_loss = torch.mean(nll_loss)
# now the GAN part
if optimizer_idx == 0:
# generator update
if cond is None:
assert not self.disc_conditional
logits_fake = self.discriminator(reconstructions.contiguous())
else:
assert self.disc_conditional
logits_fake = self.discriminator(torch.cat((reconstructions.contiguous(), cond), dim=1))
g_loss = -torch.mean(logits_fake)
try:
d_weight = self.calculate_adaptive_weight(nll_loss, g_loss, last_layer=last_layer)
except RuntimeError:
assert not self.training
d_weight = torch.tensor(0.0)
disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start)
loss = nll_loss + d_weight * disc_factor * g_loss + self.codebook_weight * codebook_loss.mean()
log = {"{}/total_loss".format(split): loss.clone().detach().mean(),
"{}/quant_loss".format(split): codebook_loss.detach().mean(),
"{}/nll_loss".format(split): nll_loss.detach().mean(),
"{}/rec_loss".format(split): rec_loss.detach().mean(),
"{}/p_loss".format(split): p_loss.detach().mean(),
"{}/d_weight".format(split): d_weight.detach(),
"{}/disc_factor".format(split): torch.tensor(disc_factor),
"{}/g_loss".format(split): g_loss.detach().mean(),
}
return loss, log
if optimizer_idx == 1:
# second pass for discriminator update
if cond is None:
logits_real = self.discriminator(inputs.contiguous().detach())
logits_fake = self.discriminator(reconstructions.contiguous().detach())
else:
logits_real = self.discriminator(torch.cat((inputs.contiguous().detach(), cond), dim=1))
logits_fake = self.discriminator(torch.cat((reconstructions.contiguous().detach(), cond), dim=1))
disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start)
d_loss = disc_factor * self.disc_loss(logits_real, logits_fake)
log = {"{}/disc_loss".format(split): d_loss.clone().detach().mean(),
"{}/logits_real".format(split): logits_real.detach().mean(),
"{}/logits_fake".format(split): logits_fake.detach().mean()
}
return d_loss, log
| 6,211 | 44.343066 | 113 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/taming/models/vqgan.py | import torch
import torch.nn.functional as F
import pytorch_lightning as pl
from image_synthesis.utils.misc import instantiate_from_config
from image_synthesis.taming.modules.diffusionmodules.model import Encoder, Decoder
from image_synthesis.taming.modules.vqvae.quantize import VectorQuantizer2 as VectorQuantizer
from image_synthesis.taming.modules.vqvae.quantize import GumbelQuantize
class VQModel(pl.LightningModule):
def __init__(self,
ddconfig,
lossconfig,
n_embed,
embed_dim,
ckpt_path=None,
ignore_keys=[],
image_key="image",
colorize_nlabels=None,
monitor=None,
remap=None,
sane_index_shape=False, # tell vector quantizer to return indices as bhw
):
super().__init__()
self.image_key = image_key
self.encoder = Encoder(**ddconfig)
self.decoder = Decoder(**ddconfig)
self.loss = instantiate_from_config(lossconfig)
self.quantize = VectorQuantizer(n_embed, embed_dim, beta=0.25,
remap=remap, sane_index_shape=sane_index_shape)
self.quant_conv = torch.nn.Conv2d(ddconfig["z_channels"], embed_dim, 1)
self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1)
if ckpt_path is not None:
self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
self.image_key = image_key
if colorize_nlabels is not None:
assert type(colorize_nlabels)==int
self.register_buffer("colorize", torch.randn(3, colorize_nlabels, 1, 1))
if monitor is not None:
self.monitor = monitor
def init_from_ckpt(self, path, ignore_keys=list()):
sd = torch.load(path, map_location="cpu")["state_dict"]
keys = list(sd.keys())
for k in keys:
for ik in ignore_keys:
if k.startswith(ik):
print("Deleting key {} from state_dict.".format(k))
del sd[k]
self.load_state_dict(sd, strict=False)
print(f"Restored from {path}")
def encode(self, x):
h = self.encoder(x)
h = self.quant_conv(h)
quant, emb_loss, info = self.quantize(h)
return quant, emb_loss, info
def decode(self, quant):
quant = self.post_quant_conv(quant)
dec = self.decoder(quant)
return dec
def decode_code(self, code_b):
quant_b = self.quantize.embed_code(code_b)
dec = self.decode(quant_b)
return dec
def forward(self, input):
quant, diff, _ = self.encode(input)
dec = self.decode(quant)
return dec, diff
def get_input(self, batch, k):
x = batch[k]
if len(x.shape) == 3:
x = x[..., None]
x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format)
return x.float()
def training_step(self, batch, batch_idx, optimizer_idx):
x = self.get_input(batch, self.image_key)
xrec, qloss = self(x)
if optimizer_idx == 0:
# autoencode
aeloss, log_dict_ae = self.loss(qloss, x, xrec, optimizer_idx, self.global_step,
last_layer=self.get_last_layer(), split="train")
self.log("train/aeloss", aeloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True)
return aeloss
if optimizer_idx == 1:
# discriminator
discloss, log_dict_disc = self.loss(qloss, x, xrec, optimizer_idx, self.global_step,
last_layer=self.get_last_layer(), split="train")
self.log("train/discloss", discloss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=True)
return discloss
def validation_step(self, batch, batch_idx):
x = self.get_input(batch, self.image_key)
xrec, qloss = self(x)
aeloss, log_dict_ae = self.loss(qloss, x, xrec, 0, self.global_step,
last_layer=self.get_last_layer(), split="val")
discloss, log_dict_disc = self.loss(qloss, x, xrec, 1, self.global_step,
last_layer=self.get_last_layer(), split="val")
rec_loss = log_dict_ae["val/rec_loss"]
self.log("val/rec_loss", rec_loss,
prog_bar=True, logger=True, on_step=True, on_epoch=True, sync_dist=True)
self.log("val/aeloss", aeloss,
prog_bar=True, logger=True, on_step=True, on_epoch=True, sync_dist=True)
self.log_dict(log_dict_ae)
self.log_dict(log_dict_disc)
return self.log_dict
def configure_optimizers(self):
lr = self.learning_rate
opt_ae = torch.optim.Adam(list(self.encoder.parameters())+
list(self.decoder.parameters())+
list(self.quantize.parameters())+
list(self.quant_conv.parameters())+
list(self.post_quant_conv.parameters()),
lr=lr, betas=(0.5, 0.9))
opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(),
lr=lr, betas=(0.5, 0.9))
return [opt_ae, opt_disc], []
def get_last_layer(self):
return self.decoder.conv_out.weight
def log_images(self, batch, **kwargs):
log = dict()
x = self.get_input(batch, self.image_key)
x = x.to(self.device)
xrec, _ = self(x)
if x.shape[1] > 3:
# colorize with random projection
assert xrec.shape[1] > 3
x = self.to_rgb(x)
xrec = self.to_rgb(xrec)
log["inputs"] = x
log["reconstructions"] = xrec
return log
def to_rgb(self, x):
assert self.image_key == "segmentation"
if not hasattr(self, "colorize"):
self.register_buffer("colorize", torch.randn(3, x.shape[1], 1, 1).to(x))
x = F.conv2d(x, weight=self.colorize)
x = 2.*(x-x.min())/(x.max()-x.min()) - 1.
return x
class GumbelVQ(VQModel):
def __init__(self,
ddconfig,
lossconfig,
n_embed,
embed_dim,
temperature_scheduler_config,
ckpt_path=None,
ignore_keys=[],
image_key="image",
colorize_nlabels=None,
monitor=None,
kl_weight=1e-8,
remap=None,
):
z_channels = ddconfig["z_channels"]
super().__init__(ddconfig,
lossconfig,
n_embed,
embed_dim,
ckpt_path=None,
ignore_keys=ignore_keys,
image_key=image_key,
colorize_nlabels=colorize_nlabels,
monitor=monitor,
)
self.loss.n_classes = n_embed
self.vocab_size = n_embed
self.quantize = GumbelQuantize(z_channels, embed_dim,
n_embed=n_embed,
kl_weight=kl_weight, temp_init=1.0,
remap=remap)
self.temperature_scheduler = instantiate_from_config(temperature_scheduler_config) # annealing of temp
if ckpt_path is not None:
self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
def temperature_scheduling(self):
self.quantize.temperature = self.temperature_scheduler(self.global_step)
def encode_to_prequant(self, x):
h = self.encoder(x)
h = self.quant_conv(h)
return h
def decode_code(self, code_b):
raise NotImplementedError
def training_step(self, batch, batch_idx, optimizer_idx):
self.temperature_scheduling()
x = self.get_input(batch, self.image_key)
xrec, qloss = self(x)
if optimizer_idx == 0:
# autoencode
aeloss, log_dict_ae = self.loss(qloss, x, xrec, optimizer_idx, self.global_step,
last_layer=self.get_last_layer(), split="train")
self.log_dict(log_dict_ae, prog_bar=False, logger=True, on_step=True, on_epoch=True)
self.log("temperature", self.quantize.temperature, prog_bar=False, logger=True, on_step=True, on_epoch=True)
return aeloss
if optimizer_idx == 1:
# discriminator
discloss, log_dict_disc = self.loss(qloss, x, xrec, optimizer_idx, self.global_step,
last_layer=self.get_last_layer(), split="train")
self.log_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=True)
return discloss
def validation_step(self, batch, batch_idx):
x = self.get_input(batch, self.image_key)
xrec, qloss = self(x, return_pred_indices=True)
aeloss, log_dict_ae = self.loss(qloss, x, xrec, 0, self.global_step,
last_layer=self.get_last_layer(), split="val")
discloss, log_dict_disc = self.loss(qloss, x, xrec, 1, self.global_step,
last_layer=self.get_last_layer(), split="val")
rec_loss = log_dict_ae["val/rec_loss"]
self.log("val/rec_loss", rec_loss,
prog_bar=True, logger=True, on_step=False, on_epoch=True, sync_dist=True)
self.log("val/aeloss", aeloss,
prog_bar=True, logger=True, on_step=False, on_epoch=True, sync_dist=True)
self.log_dict(log_dict_ae)
self.log_dict(log_dict_disc)
return self.log_dict
def log_images(self, batch, **kwargs):
log = dict()
x = self.get_input(batch, self.image_key)
x = x.to(self.device)
# encode
h = self.encoder(x)
h = self.quant_conv(h)
quant, _, _ = self.quantize(h)
# decode
x_rec = self.decode(quant)
log["inputs"] = x
log["reconstructions"] = x_rec
return log
| 10,554 | 39.28626 | 120 | py |
VQ-Diffusion | VQ-Diffusion-main/image_synthesis/taming/models/cond_transformer.py | import os, math
import torch
import torch.nn.functional as F
import pytorch_lightning as pl
from image_synthesis.utils.misc import instantiate_from_config
from image_synthesis.taming.modules.util import SOSProvider
def disabled_train(self, mode=True):
"""Overwrite model.train with this function to make sure train/eval mode
does not change anymore."""
return self
class Net2NetTransformer(pl.LightningModule):
def __init__(self,
transformer_config,
first_stage_config,
cond_stage_config,
permuter_config=None,
ckpt_path=None,
ignore_keys=[],
first_stage_key="image",
cond_stage_key="depth",
downsample_cond_size=-1,
pkeep=1.0,
sos_token=0,
unconditional=False,
):
super().__init__()
self.be_unconditional = unconditional
self.sos_token = sos_token
self.first_stage_key = first_stage_key
self.cond_stage_key = cond_stage_key
self.init_first_stage_from_ckpt(first_stage_config)
self.init_cond_stage_from_ckpt(cond_stage_config)
if permuter_config is None:
permuter_config = {"target": "image_synthesis.taming.modules.transformer.permuter.Identity"}
self.permuter = instantiate_from_config(config=permuter_config)
self.transformer = instantiate_from_config(config=transformer_config)
if ckpt_path is not None:
self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
self.downsample_cond_size = downsample_cond_size
self.pkeep = pkeep
def init_from_ckpt(self, path, ignore_keys=list()):
sd = torch.load(path, map_location="cpu")["state_dict"]
for k in sd.keys():
for ik in ignore_keys:
if k.startswith(ik):
self.print("Deleting key {} from state_dict.".format(k))
del sd[k]
self.load_state_dict(sd, strict=False)
print(f"Restored from {path}")
def init_first_stage_from_ckpt(self, config):
model = instantiate_from_config(config)
model = model.eval()
model.train = disabled_train
self.first_stage_model = model
def init_cond_stage_from_ckpt(self, config):
if config == "__is_first_stage__":
print("Using first stage also as cond stage.")
self.cond_stage_model = self.first_stage_model
elif config == "__is_unconditional__" or self.be_unconditional:
print(f"Using no cond stage. Assuming the training is intended to be unconditional. "
f"Prepending {self.sos_token} as a sos token.")
self.be_unconditional = True
self.cond_stage_key = self.first_stage_key
self.cond_stage_model = SOSProvider(self.sos_token)
else:
model = instantiate_from_config(config)
model = model.eval()
model.train = disabled_train
self.cond_stage_model = model
def forward(self, x, c):
# one step to produce the logits
_, z_indices = self.encode_to_z(x)
_, c_indices = self.encode_to_c(c)
if self.training and self.pkeep < 1.0:
mask = torch.bernoulli(self.pkeep*torch.ones(z_indices.shape,
device=z_indices.device))
mask = mask.round().to(dtype=torch.int64)
r_indices = torch.randint_like(z_indices, self.transformer.config.vocab_size)
a_indices = mask*z_indices+(1-mask)*r_indices
else:
a_indices = z_indices
cz_indices = torch.cat((c_indices, a_indices), dim=1)
# target includes all sequence elements (no need to handle first one
# differently because we are conditioning)
target = z_indices
# make the prediction
logits, _ = self.transformer(cz_indices[:, :-1])
# cut off conditioning outputs - output i corresponds to p(z_i | z_{<i}, c)
logits = logits[:, c_indices.shape[1]-1:]
return logits, target
def top_k_logits(self, logits, k):
v, ix = torch.topk(logits, k)
out = logits.clone()
out[out < v[..., [-1]]] = -float('Inf')
return out
@torch.no_grad()
def sample(self, x, c, steps, temperature=1.0, sample=False, top_k=None,
callback=lambda k: None):
x = torch.cat((c,x),dim=1)
block_size = self.transformer.get_block_size()
assert not self.transformer.training
if self.pkeep <= 0.0:
# one pass suffices since input is pure noise anyway
assert len(x.shape)==2
noise_shape = (x.shape[0], steps-1)
#noise = torch.randint(self.transformer.config.vocab_size, noise_shape).to(x)
noise = c.clone()[:,x.shape[1]-c.shape[1]:-1]
x = torch.cat((x,noise),dim=1)
logits, _ = self.transformer(x)
# take all logits for now and scale by temp
logits = logits / temperature
# optionally crop probabilities to only the top k options
if top_k is not None:
logits = self.top_k_logits(logits, top_k)
# apply softmax to convert to probabilities
probs = F.softmax(logits, dim=-1)
# sample from the distribution or take the most likely
if sample:
shape = probs.shape
probs = probs.reshape(shape[0]*shape[1],shape[2])
ix = torch.multinomial(probs, num_samples=1)
probs = probs.reshape(shape[0],shape[1],shape[2])
ix = ix.reshape(shape[0],shape[1])
else:
_, ix = torch.topk(probs, k=1, dim=-1)
# cut off conditioning
x = ix[:, c.shape[1]-1:]
else:
for k in range(steps):
callback(k)
assert x.size(1) <= block_size # make sure model can see conditioning
x_cond = x if x.size(1) <= block_size else x[:, -block_size:] # crop context if needed
logits, _ = self.transformer(x_cond)
# pluck the logits at the final step and scale by temperature
logits = logits[:, -1, :] / temperature
# optionally crop probabilities to only the top k options
if top_k is not None:
logits = self.top_k_logits(logits, top_k)
# apply softmax to convert to probabilities
probs = F.softmax(logits, dim=-1)
# sample from the distribution or take the most likely
if sample:
ix = torch.multinomial(probs, num_samples=1)
else:
_, ix = torch.topk(probs, k=1, dim=-1)
# append to the sequence and continue
x = torch.cat((x, ix), dim=1)
# cut off conditioning
x = x[:, c.shape[1]:]
return x
@torch.no_grad()
def encode_to_z(self, x):
quant_z, _, info = self.first_stage_model.encode(x)
indices = info[2].view(quant_z.shape[0], -1)
indices = self.permuter(indices)
return quant_z, indices
@torch.no_grad()
def encode_to_c(self, c):
if self.downsample_cond_size > -1:
c = F.interpolate(c, size=(self.downsample_cond_size, self.downsample_cond_size))
quant_c, _, [_,_,indices] = self.cond_stage_model.encode(c)
if len(indices.shape) > 2:
indices = indices.view(c.shape[0], -1)
return quant_c, indices
@torch.no_grad()
def decode_to_img(self, index, zshape):
index = self.permuter(index, reverse=True)
bhwc = (zshape[0],zshape[2],zshape[3],zshape[1])
quant_z = self.first_stage_model.quantize.get_codebook_entry(
index.reshape(-1), shape=bhwc)
x = self.first_stage_model.decode(quant_z)
return x
@torch.no_grad()
def log_images(self, batch, temperature=None, top_k=None, callback=None, lr_interface=False, **kwargs):
log = dict()
N = 4
if lr_interface:
x, c = self.get_xc(batch, N, diffuse=False, upsample_factor=8)
else:
x, c = self.get_xc(batch, N)
x = x.to(device=self.device)
c = c.to(device=self.device)
quant_z, z_indices = self.encode_to_z(x)
quant_c, c_indices = self.encode_to_c(c)
# create a "half"" sample
z_start_indices = z_indices[:,:z_indices.shape[1]//2]
index_sample = self.sample(z_start_indices, c_indices,
steps=z_indices.shape[1]-z_start_indices.shape[1],
temperature=temperature if temperature is not None else 1.0,
sample=True,
top_k=top_k if top_k is not None else 100,
callback=callback if callback is not None else lambda k: None)
x_sample = self.decode_to_img(index_sample, quant_z.shape)
# sample
z_start_indices = z_indices[:, :0]
index_sample = self.sample(z_start_indices, c_indices,
steps=z_indices.shape[1],
temperature=temperature if temperature is not None else 1.0,
sample=True,
top_k=top_k if top_k is not None else 100,
callback=callback if callback is not None else lambda k: None)
x_sample_nopix = self.decode_to_img(index_sample, quant_z.shape)
# det sample
z_start_indices = z_indices[:, :0]
index_sample = self.sample(z_start_indices, c_indices,
steps=z_indices.shape[1],
sample=False,
callback=callback if callback is not None else lambda k: None)
x_sample_det = self.decode_to_img(index_sample, quant_z.shape)
# reconstruction
x_rec = self.decode_to_img(z_indices, quant_z.shape)
log["inputs"] = x
log["reconstructions"] = x_rec
if self.cond_stage_key != "image":
cond_rec = self.cond_stage_model.decode(quant_c)
if self.cond_stage_key == "segmentation":
# get image from segmentation mask
num_classes = cond_rec.shape[1]
c = torch.argmax(c, dim=1, keepdim=True)
c = F.one_hot(c, num_classes=num_classes)
c = c.squeeze(1).permute(0, 3, 1, 2).float()
c = self.cond_stage_model.to_rgb(c)
cond_rec = torch.argmax(cond_rec, dim=1, keepdim=True)
cond_rec = F.one_hot(cond_rec, num_classes=num_classes)
cond_rec = cond_rec.squeeze(1).permute(0, 3, 1, 2).float()
cond_rec = self.cond_stage_model.to_rgb(cond_rec)
log["conditioning_rec"] = cond_rec
log["conditioning"] = c
log["samples_half"] = x_sample
log["samples_nopix"] = x_sample_nopix
log["samples_det"] = x_sample_det
return log
def get_input(self, key, batch):
x = batch[key]
if len(x.shape) == 3:
x = x[..., None]
if len(x.shape) == 4:
x = x.permute(0, 3, 1, 2).to(memory_format=torch.contiguous_format)
if x.dtype == torch.double:
x = x.float()
return x
def get_xc(self, batch, N=None):
x = self.get_input(self.first_stage_key, batch)
c = self.get_input(self.cond_stage_key, batch)
if N is not None:
x = x[:N]
c = c[:N]
return x, c
def shared_step(self, batch, batch_idx):
x, c = self.get_xc(batch)
logits, target = self(x, c)
loss = F.cross_entropy(logits.reshape(-1, logits.size(-1)), target.reshape(-1))
return loss
def training_step(self, batch, batch_idx):
loss = self.shared_step(batch, batch_idx)
self.log("train/loss", loss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
return loss
def validation_step(self, batch, batch_idx):
loss = self.shared_step(batch, batch_idx)
self.log("val/loss", loss, prog_bar=True, logger=True, on_step=True, on_epoch=True)
return loss
def configure_optimizers(self):
"""
Following minGPT:
This long function is unfortunately doing something very simple and is being very defensive:
We are separating out all parameters of the model into two buckets: those that will experience
weight decay for regularization and those that won't (biases, and layernorm/embedding weights).
We are then returning the PyTorch optimizer object.
"""
# separate out all parameters to those that will and won't experience regularizing weight decay
decay = set()
no_decay = set()
whitelist_weight_modules = (torch.nn.Linear, )
blacklist_weight_modules = (torch.nn.LayerNorm, torch.nn.Embedding)
for mn, m in self.transformer.named_modules():
for pn, p in m.named_parameters():
fpn = '%s.%s' % (mn, pn) if mn else pn # full param name
if pn.endswith('bias'):
# all biases will not be decayed
no_decay.add(fpn)
elif pn.endswith('weight') and isinstance(m, whitelist_weight_modules):
# weights of whitelist modules will be weight decayed
decay.add(fpn)
elif pn.endswith('weight') and isinstance(m, blacklist_weight_modules):
# weights of blacklist modules will NOT be weight decayed
no_decay.add(fpn)
# special case the position embedding parameter in the root GPT module as not decayed
no_decay.add('pos_emb')
# validate that we considered every parameter
param_dict = {pn: p for pn, p in self.transformer.named_parameters()}
inter_params = decay & no_decay
union_params = decay | no_decay
assert len(inter_params) == 0, "parameters %s made it into both decay/no_decay sets!" % (str(inter_params), )
assert len(param_dict.keys() - union_params) == 0, "parameters %s were not separated into either decay/no_decay set!" \
% (str(param_dict.keys() - union_params), )
# create the pytorch optimizer object
optim_groups = [
{"params": [param_dict[pn] for pn in sorted(list(decay))], "weight_decay": 0.01},
{"params": [param_dict[pn] for pn in sorted(list(no_decay))], "weight_decay": 0.0},
]
optimizer = torch.optim.AdamW(optim_groups, lr=self.learning_rate, betas=(0.9, 0.95))
return optimizer
| 15,049 | 42.75 | 127 | py |
Reflect | Reflect-master/distill/distill_util.py | import tensorflow as tf
from tf2_models.metrics import distill_loss, sequence_distill_loss
@tf.function(experimental_relax_shapes=True)
def get_topk_mask(inputs, k):
inputs_shape = tf.shape(inputs)
inputs_shape = tf.cast(inputs_shape, dtype=tf.int64)
values, indices = tf.nn.top_k(inputs, k=k, sorted=False)
indices = tf.cast(indices, dtype=tf.int64)
k = tf.cast(k, dtype=tf.int64)
temp_indices = tf.meshgrid(*[tf.range(d, dtype=tf.int64) for d in (tf.unstack(
inputs_shape[:(inputs.get_shape().ndims - 1)]) + [k])], indexing='ij')
temp_indices = tf.stack(temp_indices[:-1] + [indices], axis=-1)
full_indices = tf.reshape(temp_indices, [-1, inputs.get_shape().ndims])
values = tf.reshape(values, [-1])
mask_vals = tf.ones_like(values, dtype=tf.int64)
full_indices = tf.cast(
full_indices, dtype=tf.int64)
mask_st = tf.SparseTensor(indices=full_indices, values=mask_vals, dense_shape=inputs_shape)
mask = tf.sparse.to_dense(tf.sparse.reorder(mask_st))
return mask
@tf.function(experimental_relax_shapes=True)
def get_topk_masked_probs(logits, labels, temperature, k=100, padding_symbol=0):
topk_mask = (1 - tf.cast(get_topk_mask(logits, k), dtype=tf.float32)) * -10e8
teacher_probs = tf.nn.softmax((logits + topk_mask) / temperature, axis=-1)
sequence_mask = tf.cast(labels != padding_symbol, dtype=tf.float32)
masked_teacher_probs = teacher_probs * sequence_mask[..., None] + tf.eye(tf.shape(teacher_probs)[-1])[0] * (
1 - sequence_mask[..., None])
return masked_teacher_probs
@tf.function(experimental_relax_shapes=True)
def get_masked_probs(logits, labels, temperature, padding_symbol=0):
teacher_probs = tf.nn.softmax(logits / temperature, axis=-1)
sequence_mask = tf.cast(labels != padding_symbol, dtype=tf.float32)
masked_teacher_probs = teacher_probs * sequence_mask[..., None] + tf.eye(tf.shape(teacher_probs)[-1])[0] * (
1 - sequence_mask[..., None])
return masked_teacher_probs
@tf.function(experimental_relax_shapes=True)
def get_probs(logits, labels, temperature):
teacher_probs = tf.nn.softmax(logits / temperature, axis=-1)
return teacher_probs
class DistillLoss(tf.keras.losses.Loss):
def __init__(self, padding_symbol=0, tmp=1.0,
**kwargs):
super(DistillLoss, self).__init__(**kwargs)
self.tmp = tf.Variable(tmp, dtype=tf.float32, name="temp")
self.padding_symbol = tf.Variable(padding_symbol, dtype=tf.int64, name="padding_symbol")
def call(self, y_true, y_pred):
return distill_loss(y_true, y_pred, self.tmp)
class SequenceDistillLoss(tf.keras.losses.Loss):
def __init__(self, padding_symbol=0, tmp=1.0,
**kwargs):
super(SequenceDistillLoss, self).__init__(**kwargs)
self.tmp = tf.Variable(tmp, dtype=tf.float32, name="tmp")
self.padding_symbol = tf.Variable(padding_symbol, dtype=tf.int64, name="padding_symbol")
def call(self, y_true, y_pred):
return sequence_distill_loss(y_true, y_pred, self.padding_symbol, self.tmp)
def get_distill_scheduler(schedule, min=0.0, max=1.0, decay_steps=10000):
if schedule is "exp":
scheduler = tf.keras.optimizers.schedules.ExponentialDecay(
max,
decay_steps=1000,
decay_rate=0.96,
staircase=True)
elif schedule is 'crs':
scheduler = tf.keras.experimental.CosineDecayRestarts(
max,
decay_steps,
t_mul=2.0,
m_mul=0.9,
alpha=0.001,
)
elif schedule is 'lnr':
a = (max - min) / decay_steps
scheduler = lambda x: max - a*x
elif schedule is 'stp':
scheduler = lambda x: max if x < decay_steps else min
else:
scheduler = lambda x: max
return scheduler | 3,653 | 35.54 | 110 | py |
Reflect | Reflect-master/distill/distiller.py | import tensorflow as tf
import os
from distill.distill_util import get_distill_scheduler
from tf2_models.train_utils import ExponentialDecayWithWarmpUp
from tf2_models.trainer import OPTIMIZER_DIC
import numpy as np
class Distiller(object):
''' Pipeline for offline distillation.
'''
def __init__(self, hparams, distill_params, teacher_model, student_model, task,
teacher_log_dir, student_log_dir, teacher_ckpt_dir, student_ckpt_dir):
self.teacher_model = teacher_model
self.student_model = student_model
self.task = task
self.distill_params = distill_params
self.temperature = tf.convert_to_tensor(distill_params.distill_temp)
self.distill_loss = self.task.get_distill_loss_fn(self.distill_params)
self.task_loss = self.task.get_loss_fn()
self.metrics = self.task.metrics()
self.task_probs_fn = self.task.get_probs_fn()
self.hparams = hparams
self.create_student_optimizer()
self.setup_ckp_and_summary(student_ckpt_dir, student_log_dir, teacher_ckpt_dir, teacher_log_dir)
self.setup_models(distill_params, task)
self.distillrate_scheduler = get_distill_scheduler(distill_params.distill_schedule,
min=distill_params.distill_min_rate,
max=distill_params.student_distill_rate)
def create_student_optimizer(self):
student_initial_learning_rate = self.distill_params.student_learning_rate
if 'crs' in self.distill_params.schedule:
lr_schedule = (
tf.keras.experimental.CosineDecayRestarts(
student_initial_learning_rate,
first_decay_steps=self.distill_params.student_decay_steps,
t_mul=5.0, #0.2
m_mul=self.distill_params.student_decay_rate,
alpha=0.001,
))
else:
lr_schedule = ExponentialDecayWithWarmpUp(
initial_learning_rate=student_initial_learning_rate,
decay_steps=self.distill_params.student_decay_steps,
decay_rate=self.distill_params.student_decay_rate,
warmup_steps=self.distill_params.student_warmup_steps,
hold_base_rate_steps=self.distill_params.student_hold_base_rate_steps)
self.student_optimizer = OPTIMIZER_DIC[self.distill_params.student_optimizer](
learning_rate=lr_schedule, epsilon=1e-08, clipnorm=1.0)
def setup_ckp_and_summary(self, student_ckpt_dir, student_log_dir, teacher_ckpt_dir, teacher_log_dir):
# Init checkpoints
self.teacher_ckpt = tf.train.Checkpoint(net=self.teacher_model)
self.teacher_manager = tf.train.CheckpointManager(self.teacher_ckpt, teacher_ckpt_dir, max_to_keep=self.hparams.max_checkpoints)
self.student_ckpt = tf.train.Checkpoint(step=tf.Variable(1),
optimizer=self.student_optimizer,
net=self.student_model)
self.student_manager = tf.train.CheckpointManager(self.student_ckpt, student_ckpt_dir,
keep_checkpoint_every_n_hours=self.hparams.keep_checkpoint_every_n_hours,
max_to_keep=self.hparams.max_checkpoints)
# Init summary
student_summary_dir = os.path.join(student_log_dir, 'summaries')
tf.io.gfile.makedirs(student_log_dir)
self.summary_writer = tf.compat.v2.summary.create_file_writer(os.path.join(student_summary_dir, 'train'))
tf.compat.v2.summary.experimental.set_step(self.student_optimizer.iterations)
def setup_models(self, distill_params, task):
x, y = iter(self.task.valid_dataset).next()
self.student_model(x, padding_symbol=self.task.input_padding_symbol, training=True)
self.student_model.summary()
self.teacher_model(x, padding_symbol=self.task.input_padding_symbol, training=True)
self.teacher_model.summary()
self.student_model.compile(
optimizer=self.student_optimizer,
loss=self.task_loss,
metrics=[self.metrics])
self.teacher_model.compile(
loss=self.task_loss,
metrics=[self.metrics])
def restore_teacher(self):
''' Restore the teacher model from its checkpoint.
'''
self.teacher_ckpt.restore(self.teacher_manager.latest_checkpoint)
if self.teacher_manager.latest_checkpoint:
print("Restored teacher from {}".format(self.teacher_manager.latest_checkpoint))
else:
print("Initializing teacher from scratch.")
def restore_student(self):
''' Restore the student model from its checkpoint.
'''
self.student_ckpt.restore(self.student_manager.latest_checkpoint)
if self.student_manager.latest_checkpoint:
print("Restored student from {}".format(self.student_manager.latest_checkpoint))
else:
print("Initializing student from scratch.")
def save_student(self):
self.student_ckpt.step.assign_add(1)
save_path = self.student_manager.save()
tf.print("Saved student checkpoint", save_path)
def distill_loop(self):
''' Offline Distillation main loop.
'''
# logging.info('Distribute strategy: mirrored.')
# strategy = tf.distribute.MirroredStrategy()
# train_dataset = strategy.experimental_distribute_dataset(self.task.train_dataset)
# valid_dataset = strategy.experimental_distribute_dataset(self.task.valid_dataset)
@tf.function(experimental_relax_shapes=True)
def student_train_step(x, teacher_y, y_true):
''' Training step for the student model (this is the only training step for offline distillation).
:param x: input
:param y: output of the teacher model, used to compute distill loss
:param y_true: actual outputs, used to compute actual loss
:return:
distill_loss
actual_loss
'''
student_distill_rate = self.distillrate_scheduler(self.student_optimizer.iterations)
student_gold_rate = 1 - student_distill_rate
with tf.GradientTape() as tape:
logits = self.student_model(x, padding_symbol=self.task.input_padding_symbol, training=True)
distill_loss = self.distill_loss(y_pred=logits, y_true=teacher_y)
reg_loss = tf.math.add_n(self.student_model.losses)
actual_loss = self.task_loss(y_pred=logits, y_true=y_true)
final_loss = student_distill_rate * distill_loss + \
student_gold_rate * actual_loss + reg_loss
grads = tape.gradient(final_loss, self.student_model.trainable_weights)
self.student_model.optimizer.apply_gradients(zip(grads, self.student_model.trainable_weights),
name="student_optimizer")
return distill_loss, actual_loss, student_distill_rate
@tf.function
def epoch_loop():
step = 0
for x,y in self.task.train_dataset:
teacher_logits = self.teacher_model(x, padding_symbol=self.task.input_padding_symbol, training=True)
teacher_probs = self.task_probs_fn(logits=teacher_logits, labels=y, temperature=self.temperature)
distill_loss, actual_loss, student_distill_rate = student_train_step(x=x, teacher_y=teacher_probs, y_true=y)
# Log every 200 batches.
if step % 200 == 0:
with tf.summary.experimental.summary_scope("student_train"):
tf.summary.scalar('student_learning_rate',
self.student_model.optimizer.learning_rate(self.student_model.optimizer.iterations),
)
tf.summary.scalar('fine_distill_loss',
distill_loss)
tf.summary.scalar('student_distill_rate',
student_distill_rate)
step += 1
# Stop at the end of the epoch
if (step % self.task.n_train_batches) == 0:
with tf.summary.experimental.summary_scope("student_train"):
tf.summary.scalar('distill_loss', distill_loss)
tf.summary.scalar('actual_loss', actual_loss)
break
@tf.function
def summarize(teacher_eval_results, student_eval_results):
with tf.summary.experimental.summary_scope("eval_teacher"):
for i, m_name in enumerate(self.teacher_model.metrics_names):
tf.summary.scalar(m_name, teacher_eval_results[i])
with tf.summary.experimental.summary_scope("eval_student"):
for i, m_name in enumerate(self.student_model.metrics_names):
tf.summary.scalar(m_name, student_eval_results[i])
with self.summary_writer.as_default():
for epoch in np.arange(self.distill_params.n_epochs):
epoch_loop()
# Evaluate Teacher
teacher_eval_results = self.teacher_model.evaluate(self.task.valid_dataset,
steps=self.task.n_valid_batches)
# Evaluate Student
student_eval_results = self.student_model.evaluate(self.task.valid_dataset,
steps=self.task.n_valid_batches)
summarize(teacher_eval_results, student_eval_results)
pow2 = [0, 1, 2, 4, 8, 16, 32, 64, 128, 256, 512]
if self.hparams.keep_some_checkpoints:
if (epoch in pow2) or (epoch == (self.distill_params.n_epochs - 1)):
self.save_student()
else:
self.save_student()
| 9,284 | 44.292683 | 132 | py |
Reflect | Reflect-master/tf2_models/embedding.py | import tensorflow as tf
from tf2_models.common_layers import get_initializer, shape_list
class SharedEmbeddings(tf.keras.layers.Layer):
"""Construct shared token embeddings.
"""
def __init__(self, vocab_size, hidden_size, initializer_range=None, regularizer=None, **kwargs):
super(SharedEmbeddings, self).__init__(**kwargs)
self.vocab_size = vocab_size
self.hidden_size = hidden_size
self.initializer_range = hidden_size ** -0.5 if initializer_range is None else initializer_range
self.regularizer = regularizer
def build(self, input_shape):
"""Build shared word embedding layer
Shared weights logic adapted from
https://github.com/tensorflow/models/blob/a009f4fb9d2fc4949e32192a944688925ef78659/official/transformer/v2/embedding_layer.py#L24
"""
self.weight = self.add_weight(
"weight",
shape=[self.vocab_size, self.hidden_size],
initializer=get_initializer(self.initializer_range),
regularizer=self.regularizer)
super(SharedEmbeddings, self).build(input_shape)
def call(self, inputs, mode="embedding"):
"""Get token embeddings of inputs.
Args:
inputs: list of three int64 tensors with shape [batch_size, length]: (input_ids, position_ids, token_type_ids)
mode: string, a valid value is one of "embedding" and "linear".
Returns:
outputs: (1) If mode == "embedding", output embedding tensor, float32 with
shape [batch_size, length, embedding_size]; (2) mode == "linear", output
linear tensor, float32 with shape [batch_size, length, vocab_size].
Raises:
ValueError: if mode is not valid.
Shared weights logic adapted from
https://github.com/tensorflow/models/blob/a009f4fb9d2fc4949e32192a944688925ef78659/official/transformer/v2/embedding_layer.py#L24
"""
if mode == "embedding":
return self._embedding(inputs)
elif mode == "linear":
return self._linear(inputs)
else:
raise ValueError("mode {} is not valid.".format(mode))
def _embedding(self, input_ids):
"""Applies embedding based on inputs tensor."""
return tf.gather(self.weight, input_ids)
def _linear(self, inputs):
"""Computes logits by running inputs through a linear layer.
Args:
inputs: A float32 tensor with shape [..., hidden_size]
Returns:
float32 tensor with shape [..., vocab_size].
"""
first_dims = shape_list(inputs)[:-1]
x = tf.reshape(inputs, [-1, self.hidden_size])
logits = tf.matmul(x, self.weight, transpose_b=True)
return tf.reshape(logits, first_dims + [self.vocab_size]) | 2,633 | 38.313433 | 137 | py |
Reflect | Reflect-master/tf2_models/lm_transformer.py | import tensorflow as tf
from tf2_models.common_layers import get_initializer, shape_list
from tf2_models.embedding import SharedEmbeddings
from tf2_models.transformer_layers import Block
from tf2_models.transformers import *
class LmGPT2(tf.keras.Model):
def __init__(self, hparams, scope='lm_gpt2', *inputs, **kwargs):
del kwargs['cl_token']
super(LmGPT2, self).__init__(hparams, *inputs, **kwargs)
self.scope = scope
self.rep_index = 1
self.rep_layer = None
self.model_name = '_'.join([self.scope,
'h-'+str(hparams.embedding_dim),
'd-'+str(hparams.depth),
'rdrop-'+str(hparams.resid_pdrop),
'adrop-' + str(hparams.attn_pdrop),
'indrop-'+str(hparams.embd_pdrop)])
self.create_vars(hparams)
@tf.function
def create_vars(self, hparams):
self.transformer = GPT2(hparams, name='transformer')
def call(self, inputs, padding_symbol=None, **kwargs):
transformer_outputs = self.transformer(inputs, **kwargs)
hidden_states = transformer_outputs[0]
lm_logits = self.transformer.wte(hidden_states, mode="linear")
#outputs = (lm_logits,) + transformer_outputs[1:]
return lm_logits # lm_logits, presents, (all hidden_states), (attentions)
def detailed_call(self, inputs, padding_symbol=None, **kwargs):
transformer_outputs = self.transformer(inputs, **kwargs)
hidden_states = transformer_outputs[0]
lm_logits = self.transformer.wte(hidden_states, mode="linear")
outputs = (lm_logits,) + transformer_outputs
return outputs # lm_logits, presents, (all hidden_states), (attentions)
class LmGPT2SharedWeights(LmGPT2):
def __init__(self, hparams, scope='lm_gpt2_shared_weights', *inputs, **kwargs):
super(LmGPT2SharedWeights, self).__init__(hparams, scope=scope, *inputs, **kwargs)
@tf.function
def create_vars(self, hparams):
self.transformer = GPT2SharedWeights(hparams, name='shared_transformer')
def call(self, inputs, padding_symbol=None, **kwargs):
transformer_outputs = self.transformer(inputs, **kwargs)
hidden_states = transformer_outputs[0]
lm_logits = self.transformer.wte(hidden_states, mode="linear")
#outputs = (lm_logits,) + transformer_outputs[1:]
return lm_logits # lm_logits, presents, (all hidden_states), (attentions)
class ClassifierGPT2(tf.keras.Model):
def __init__(self, hparams, scope='cl_gpt2',*inputs, **kwargs):
self.cl_token = kwargs['cl_token']
del kwargs['cl_token']
super(ClassifierGPT2, self).__init__(hparams, *inputs, **kwargs)
self.rep_index = 2
self.rep_layer = None
self.scope = scope
self.hparams = hparams
self.model_name = '_'.join([self.scope,
'h-'+str(hparams.embedding_dim),
'd-'+str(hparams.depth),
'rdrop-'+str(hparams.resid_pdrop),
'adrop-' + str(hparams.attn_pdrop),
'indrop-'+str(hparams.embd_pdrop)])
self.regularizer = tf.keras.regularizers.l1_l2(l1=0.00,
l2=0.0001)
self.create_vars(**kwargs)
#@tf.function
def create_vars(self,**kwargs):
self.transformer = GPT2(self.hparams, name='transformer',
**kwargs)
self.e2c = tf.keras.layers.Dense(units=self.hparams.num_labels,
kernel_initializer=get_initializer(self.hparams.initializer_range),
name='e2c')
def call(self, inputs, padding_symbol=None, **kwargs):
@tf.function(experimental_relax_shapes=True)
def _call(batch_size, inputs, transformer_outputs):
mask = tf.cast(inputs != 0, dtype=tf.int32)
inputs_lengths = tf.reduce_sum(mask, axis=-1) - 1
batch_indices = tf.range(batch_size)
indices = tf.concat([batch_indices[..., None], inputs_lengths[..., None]], -1)
hidden_states = tf.gather_nd(transformer_outputs[0], indices)
cl_logits = self.e2c(hidden_states)
return cl_logits
# Add CL token:
batch_size = tf.shape(inputs)[0]
#cl_token = tf.reshape(tf.convert_to_tensor(self.cl_token[0], dtype=tf.int64)[None], (-1,1))
#cl_tokens = tf.tile(cl_token, (batch_size, 1))
#inputs = tf.concat([cl_tokens, inputs], axis=-1)
transformer_outputs = self.transformer(inputs, **kwargs)
cl_logits = _call(batch_size, inputs, transformer_outputs)
return cl_logits
def detailed_call(self, inputs, padding_symbol=None, **kwargs):
@tf.function(experimental_relax_shapes=True)
def _call(batch_size, inputs, transformer_outputs):
mask = tf.cast(inputs != 0, dtype=tf.int32)
inputs_lengths = tf.reduce_sum(mask, axis=-1) - 1
batch_indices = tf.range(batch_size)
indices = tf.concat([batch_indices[..., None], inputs_lengths[..., None]], -1)
hidden_states = tf.gather_nd(transformer_outputs[0], indices)
cl_logits = self.e2c(hidden_states)
return cl_logits, hidden_states
# Add CL token:
batch_size = tf.shape(inputs)[0]
#cl_token = tf.reshape(tf.convert_to_tensor(self.cl_token[0], dtype=tf.int64)[None], (-1,1))
#cl_tokens = tf.tile(cl_token, (batch_size, 1))
#inputs = tf.concat([cl_tokens, inputs], axis=-1)
transformer_outputs = self.transformer(inputs, **kwargs)
cl_logits, hidden_states = _call(batch_size, inputs, transformer_outputs)
outputs = (cl_logits, hidden_states) + transformer_outputs
return outputs
class ClassifierGPT2SharedWeights(ClassifierGPT2):
def __init__(self, hparams, scope='cl_gpt2_shared_weights', *inputs, **kwargs):
super(ClassifierGPT2SharedWeights, self).__init__(hparams, scope=scope, *inputs, **kwargs)
@tf.function
def create_vars(self):
self.transformer = GPT2SharedWeights(self.hparams, name='shared_transformer')
self.e2c = tf.keras.layers.Dense(units=self.hparams.num_labels,
kernel_initializer=get_initializer(self.hparams.initializer_range),
name='e2c')
class ClassifierBERT(tf.keras.Model):
def __init__(self, hparams, scope='cl_bert',*inputs, **kwargs):
self.cl_token = kwargs['cl_token']
del kwargs['cl_token']
super(ClassifierBERT, self).__init__(hparams, *inputs, **kwargs)
self.scope = scope
self.hparams = hparams
self.rep_index = 2
self.rep_layer = None
self.model_name = '_'.join([self.scope,
'h-'+str(hparams.embedding_dim),
'd-'+str(hparams.depth),
'rdrop-'+str(hparams.resid_pdrop),
'adrop-' + str(hparams.attn_pdrop),
'indrop-'+str(hparams.embd_pdrop)])
self.regularizer = tf.keras.regularizers.l1_l2(l1=0.00,
l2=0.0001)
self.create_vars(**kwargs)
#@tf.function
def create_vars(self,**kwargs):
self.transformer = Bert(self.hparams, name='transformer',
**kwargs)
self.e2c = tf.keras.layers.Dense(units=self.hparams.num_labels,
kernel_initializer=get_initializer(self.hparams.initializer_range),
name='e2c')
def call(self, inputs, padding_symbol=None, add_cls=True, **kwargs):
@tf.function(experimental_relax_shapes=True)
def _call(batch_size, inputs, transformer_outputs):
#mask = tf.cast(inputs != 0, dtype=tf.int32)
#inputs_lengths = tf.reduce_sum(mask, axis=-1) - 1
#batch_indices = tf.range(batch_size)
#indices = tf.concat([batch_indices[..., None], inputs_lengths[..., None]], -1)
hidden_states = transformer_outputs[0][:,0]#tf.gather_nd(transformer_outputs[0], indices)
cl_logits = self.e2c(hidden_states, **kwargs)
return cl_logits
# Add CL token:
batch_size = tf.shape(inputs)[0]
if add_cls:
cl_token = tf.reshape(tf.convert_to_tensor(self.cl_token[0], dtype=tf.int64)[None], (-1,1))
cl_tokens = tf.tile(cl_token, (batch_size, 1))
inputs = tf.concat([cl_tokens, inputs], axis=-1)
transformer_outputs = self.transformer(inputs, **kwargs)
cl_logits = _call(batch_size, inputs, transformer_outputs)
return cl_logits
def detailed_call(self, inputs, padding_symbol=None, add_cls=True, **kwargs):
@tf.function(experimental_relax_shapes=True)
def _call(batch_size, inputs, transformer_outputs):
hidden_states = transformer_outputs[0][:, 0]
cl_logits = self.e2c(hidden_states)
return cl_logits, hidden_states
# Add CL token:
batch_size = tf.shape(inputs)[0]
if add_cls:
cl_token = tf.reshape(tf.convert_to_tensor(self.cl_token[0], dtype=tf.int64)[None], (-1,1))
cl_tokens = tf.tile(cl_token, (batch_size, 1))
inputs = tf.concat([cl_tokens, inputs], axis=-1)
transformer_outputs = self.transformer(inputs, **kwargs)
cl_logits, hidden_states = _call(batch_size, inputs, transformer_outputs)
reps_start_index = 1 if add_cls else 0
outputs = (cl_logits, hidden_states, transformer_outputs[0][:,reps_start_index:,:]) + transformer_outputs
return outputs
def get_input_embeddings(self, inputs, add_cls=True, **kwargs):
# Add CL token:
batch_size = tf.shape(inputs)[0]
if add_cls:
cl_token = tf.reshape(tf.convert_to_tensor(self.cl_token[0], dtype=tf.int64)[None], (-1, 1))
cl_tokens = tf.tile(cl_token, (batch_size, 1))
inputs = tf.concat([cl_tokens, inputs], axis=-1)
outputs = self.transformer.get_input_embeddings(inputs, **kwargs)
return outputs
def call_with_embeddings(self, input_embeddings, input_shape, padding_mask, past , **kwargs):
transformer_outputs = self.transformer.call_with_embeddings(input_embeddings=input_embeddings,
input_shape=input_shape, padding_mask=padding_mask,
past=past, **kwargs)
hidden_states = transformer_outputs[0][:, 0]
cl_logits = self.e2c(hidden_states)
return cl_logits, hidden_states
class ClassifierBERTSharedWeights(ClassifierBERT):
def __init__(self, hparams, scope='cl_bert_shared', *inputs, **kwargs):
super(ClassifierBERTSharedWeights, self).__init__(hparams, scope=scope, *inputs, **kwargs)
# @tf.function
def create_vars(self, **kwargs):
self.transformer = BertSharedWeights(self.hparams, name='transformer',
**kwargs)
self.e2c = tf.keras.layers.Dense(units=self.hparams.num_labels,
kernel_initializer=get_initializer(self.hparams.initializer_range),
name='e2c')
| 10,814 | 39.965909 | 109 | py |
Reflect | Reflect-master/tf2_models/ff.py | import tensorflow as tf
import numpy as np
class VanillaFF(tf.keras.models.Sequential):
def __init__(self, hparams, scope="cl_vff", *inputs, **kwargs):
if 'cl_token' in kwargs:
del kwargs['cl_token']
super(VanillaFF, self).__init__()
self.scope = scope
self.hparams = hparams
self.model_name = '_'.join([self.scope,
'h-' + '.'.join([str(x) for x in self.hparams.hidden_dim]),
'd-' + str(self.hparams.depth),
'hdrop-' + str(self.hparams.hidden_dropout_rate),
'indrop-' + str(self.hparams.input_dropout_rate)])
self.regularizer = tf.keras.regularizers.l1_l2(l1=0.00001,
l2=0.00001)
self.create_vars()
self.rep_index = 1
self.rep_layer = -1
def create_vars(self):
self.flat = tf.keras.layers.Flatten()
# self.batch_norm = tf.keras.layers.BatchNormalization()
# self.batch_norm.trainable = True
self.indrop = tf.keras.layers.Dropout(self.hparams.input_dropout_rate)
self.activation = tf.keras.layers.Activation('relu')
self.hidden_layers = []
self.hidden_batch_norms = []
self.hidden_dropouts = []
for i in np.arange(self.hparams.depth):
self.hidden_layers.append(tf.keras.layers.Dense(self.hparams.hidden_dim[i],
activation=None, #'relu',
kernel_regularizer=self.regularizer))
self.hidden_batch_norms.append(tf.keras.layers.BatchNormalization())
self.hidden_batch_norms[i].trainable = True
self.hidden_dropouts.append(tf.keras.layers.Dropout(self.hparams.hidden_dropout_rate))
self.final_dense = tf.keras.layers.Dense(self.hparams.output_dim,
kernel_regularizer=self.regularizer)
def call(self, inputs, padding_symbol=None, training=None, **kwargs):
x = self.flat(inputs, **kwargs)
# x = self.batch_norm(x, training=training, **kwargs)
x = self.indrop(x, training=training, **kwargs)
for i in np.arange(self.hparams.depth):
x = self.hidden_layers[i](x, training=training, **kwargs)
x = self.activation(x)
x = self.hidden_batch_norms[i](x, training=training, **kwargs)
x = self.hidden_dropouts[i](x, training=training, **kwargs)
logits = self.final_dense(x, training=training, **kwargs)
return logits
def detailed_call(self, inputs, padding_symbol=None, training=None, **kwargs):
layer_activations = []
x = self.flat(inputs, **kwargs)
x = self.indrop(x, training=None, **kwargs)
layer_activations.append(x)
for i in np.arange(self.hparams.depth):
x = self.hidden_layers[i](x, training=training, **kwargs)
x = self.activation(x)
x = self.hidden_batch_norms[i](x, training=training, **kwargs)
x = self.hidden_dropouts[i](x, training=training, **kwargs)
layer_activations.append(x)
pnltimt = x
logits = self.final_dense(x, training=None, **kwargs)
return logits, pnltimt, layer_activations
| 3,116 | 36.107143 | 92 | py |
Reflect | Reflect-master/tf2_models/common_layers.py | import tensorflow as tf
import numpy as np
from tensorflow.python.framework import tensor_shape
from tensorflow.python.util import nest
def gelu(x):
"""Gaussian Error Linear Unit.
This is a smoother version of the RELU.
Original paper: https://arxiv.org/abs/1606.08415
Args:
x: float Tensor to perform activation.
Returns:
`x` with the GELU activation applied.
"""
cdf = 0.5 * (1.0 + tf.tanh(
(np.sqrt(2 / np.pi) * (x + 0.044715 * tf.pow(x, 3)))))
return x * cdf
def shape_list(x):
"""Deal with dynamic shape in tensorflow cleanly."""
static = x.shape.as_list()
dynamic = tf.shape(x)
return [dynamic[i] if s is None else s for i, s in enumerate(static)]
def get_initializer(initializer_range=0.02):
"""Creates a `tf.initializers.truncated_normal` with the given range.
Args:
initializer_range: float, initializer range for stddev.
Returns:
TruncatedNormal initializer with stddev = `initializer_range`.
"""
return tf.keras.initializers.TruncatedNormal(stddev=initializer_range)
def make_variable_state_initializer(**kwargs):
def variable_state_initializer(shape, batch_size, dtype, index):
args = kwargs.copy()
if args.get('name'):
args['name'] = args['name'] + '_' + str(index)
else:
args['name'] = 'init_state_' + str(index)
args['shape'] = shape
args['dtype'] = dtype
var = tf.get_variable(**args)
var = tf.expand_dims(var, 0)
var = tf.tile(var, tf.pack([batch_size] + [1] * len(shape)))
var.set_shape(_state_size_with_prefix(shape, prefix=[None]))
return var
return variable_state_initializer
def get_initial_cell_state(cell, initializer, batch_size, dtype):
"""Return state tensor(s), initialized with initializer.
Args:
cell: RNNCell.
batch_size: int, float, or unit Tensor representing the batch size.
initializer: function with two arguments, shape and dtype, that
determines how the state is initialized.
dtype: the data type to use for the state.
Returns:
If `state_size` is an int or TensorShape, then the return value is a
`N-D` tensor of shape `[batch_size x state_size]` initialized
according to the initializer.
If `state_size` is a nested list or tuple, then the return value is
a nested list or tuple (of the same structure) of `2-D` tensors with
the shapes `[batch_size x s]` for each s in `state_size`.
"""
state_size = cell.state_size
if nest.is_sequence(state_size):
state_size_flat = nest.flatten(state_size)
init_state_flat = [
initializer(s, batch_size, dtype, i)
for i, s in enumerate(state_size_flat)]
init_state = nest.pack_sequence_as(structure=state_size,
flat_sequence=init_state_flat)
else:
init_state_size = state_size
init_state = initializer(init_state_size, batch_size, dtype, None)
return init_state
def _generate_variable_state(batch_size_tensor, state_size, dtype):
"""Generate a variable tensor with shape [batch_size, state_size]."""
def create_variable(unnested_state_size):
flat_dims = tensor_shape.as_shape(unnested_state_size).as_list()
init_state_size = [batch_size_tensor] + flat_dims
return tf.Variable(init_state_size, dtype=dtype)
if nest.is_sequence(state_size):
return nest.map_structure(create_variable, state_size)
else:
return create_variable(state_size)
| 3,398 | 34.041237 | 72 | py |
Reflect | Reflect-master/tf2_models/lm_lstm.py | import absl
import tensorflow as tf
import numpy as np
from tensorboard.compat.tensorflow_stub import tensor_shape
from tensorflow.python.util import nest
from tf2_models.common_layers import get_initializer
from tf2_models.embedding import SharedEmbeddings
from tf2_models.utils import create_init_var
class LmLSTM(tf.keras.Model):
def __init__(self, hparams, scope="lm_lstm",*inputs, **kwargs):
del kwargs['cl_token']
super(LmLSTM, self).__init__(*inputs, **kwargs)
self.hparams = hparams
self.scope = scope
self.rep_index = 2
self.rep_layer = -1
self.model_name = '_'.join([self.scope,
'em-'+str(self.hparams.embedding_dim),
'h-'+str(self.hparams.hidden_dim),
'd-'+str(self.hparams.depth),
'hdrop-'+str(self.hparams.hidden_dropout_rate),
'indrop-'+str(self.hparams.input_dropout_rate)])
self.regularizer = tf.keras.regularizers.l1_l2(l1=0.00,
l2=0.00001)
self.create_vars()
@tf.function
def create_vars(self):
self.input_embedding = tf.compat.v2.keras.layers.Embedding(input_dim=self.hparams.input_dim,
output_dim=self.hparams.embedding_dim,
input_shape=(None, None),
mask_zero=True,
embeddings_regularizer=self.regularizer,
name='input_embedding')
self.input_embedding_dropout = tf.keras.layers.Dropout(self.hparams.input_dropout_rate)
self.output_embedding_dropout = tf.keras.layers.Dropout(self.hparams.hidden_dropout_rate)
self.output_embedding = tf.compat.v2.keras.layers.Dense(units=self.hparams.output_dim,
kernel_regularizer=self.regularizer,
bias_regularizer=self.regularizer,
name='output_projection')
self.stacked_rnns = []
for _ in np.arange(self.hparams.depth):
self.stacked_rnns.append(tf.keras.layers.LSTM(units=self.hparams.hidden_dim,
return_sequences=True,
return_state=True,
go_backwards=False,
stateful=False,
unroll=False,
time_major=False,
recurrent_dropout=self.hparams.hidden_dropout_rate,
dropout=self.hparams.hidden_dropout_rate,
kernel_regularizer=self.regularizer,
recurrent_regularizer=self.regularizer,
bias_regularizer=self.regularizer,
))
@tf.function(experimental_relax_shapes=True)
def call(self, inputs, **kwargs):
if 'training' in kwargs:
training = kwargs['training']
else:
training = False
embedded_input = self.input_embedding_dropout(self.input_embedding(inputs),training=training)
rnn_outputs = embedded_input
input_mask = self.input_embedding.compute_mask(inputs)
float_input_mask = tf.cast(input_mask, dtype=tf.float32)
for i in np.arange(self.hparams.depth):
rnn_outputs, state_h, state_c = self.stacked_rnns[i](rnn_outputs, mask=input_mask, training=training)
rnn_outputs = self.output_embedding_dropout(rnn_outputs, training=training)
logits = self.output_embedding(rnn_outputs)
logits = logits * float_input_mask[...,None] + tf.eye(self.hparams.output_dim)[0] * (1 - float_input_mask[...,None])
return logits
class ClassifierLSTM(tf.keras.Model):
def __init__(self, hparams, scope="cl_lstm", *inputs, **kwargs):
del kwargs['cl_token']
super(ClassifierLSTM, self).__init__(*inputs, **kwargs)
self.hparams = hparams
self.scope = scope
self.rep_index = 2
self.rep_layer = -1
self.model_name = '_'.join([self.scope,
'em-'+str(self.hparams.embedding_dim),
'h-'+str(self.hparams.hidden_dim),
'd-'+str(self.hparams.depth),
'hdrop-'+str(self.hparams.hidden_dropout_rate),
'indrop-'+str(self.hparams.input_dropout_rate)])
self.regularizer = tf.keras.regularizers.l1_l2(l1=0.00,
l2=0.00001)
self.create_vars()
@tf.function
def create_vars(self):
self.input_embedding = tf.compat.v2.keras.layers.Embedding(input_dim=self.hparams.input_dim,
output_dim=self.hparams.embedding_dim,
input_shape=(None, None),
mask_zero=True,
embeddings_regularizer=self.regularizer,
name='input_embedding')
self.input_embedding_dropout = tf.keras.layers.Dropout(self.hparams.input_dropout_rate)
self.output_embedding_dropout = tf.keras.layers.Dropout(self.hparams.hidden_dropout_rate)
self.output_embedding = tf.compat.v2.keras.layers.Dense(units=self.hparams.output_dim,
kernel_regularizer=self.regularizer,
bias_regularizer=self.regularizer,
name='output_projection')
self.stacked_rnns = []
for _ in np.arange(self.hparams.depth):
self.stacked_rnns.append(tf.keras.layers.LSTM(units=self.hparams.hidden_dim,
return_sequences=True,
return_state=True,
go_backwards=False,
stateful=False,
unroll=False,
time_major=False,
recurrent_dropout=self.hparams.hidden_dropout_rate,
dropout=self.hparams.hidden_dropout_rate,
kernel_regularizer=self.regularizer,
recurrent_regularizer=self.regularizer,
bias_regularizer=self.regularizer,
))
def call(self, inputs, **kwargs):
if 'training' in kwargs:
training = kwargs['training']
else:
training = False
@tf.function(experimental_relax_shapes=True)
def _call(inputs, training):
embedded_input = self.input_embedding_dropout(self.input_embedding(inputs),training=training)
rnn_outputs = embedded_input
input_mask = self.input_embedding.compute_mask(inputs)
inputs_length = tf.reduce_sum(tf.cast(input_mask, dtype=tf.int32), axis=-1)
for i in np.arange(self.hparams.depth):
rnn_outputs, state_h, state_c = self.stacked_rnns[i](rnn_outputs, mask=input_mask, training=training)
rnn_outputs = self.output_embedding_dropout(rnn_outputs, training=training)
batch_size = tf.shape(rnn_outputs)[0]
bach_indices = tf.expand_dims(tf.range(batch_size), 1)
final_indexes = tf.concat([bach_indices, tf.expand_dims(tf.cast(inputs_length - 1, dtype=tf.int32), 1)], axis=-1)
final_rnn_outputs = tf.gather_nd(rnn_outputs, final_indexes)
logits = self.output_embedding(final_rnn_outputs)
return logits
return _call(inputs, training)
#@tf.function(experimental_relax_shapes=True)
def detailed_call(self, inputs, **kwargs):
if 'training' in kwargs:
training = kwargs['training']
else:
training = False
@tf.function(experimental_relax_shapes=True)
def _call(inputs, training):
embedded_input = self.input_embedding_dropout(self.input_embedding(inputs), training=training)
rnn_outputs = embedded_input
input_mask = self.input_embedding.compute_mask(inputs)
inputs_length = tf.reduce_sum(tf.cast(input_mask, dtype=tf.int32), axis=-1)
hidden_activation = [embedded_input]
for i in np.arange(self.hparams.depth):
rnn_outputs, state_h, state_c = self.stacked_rnns[i](rnn_outputs, mask=input_mask, training=training)
hidden_activation.append(rnn_outputs)
rnn_outputs = self.output_embedding_dropout(rnn_outputs, training=training)
batch_size = tf.shape(rnn_outputs)[0]
bach_indices = tf.expand_dims(tf.range(batch_size), 1)
final_indexes = tf.concat([bach_indices, tf.expand_dims(tf.cast(inputs_length - 1, dtype=tf.int32), 1)], axis=-1)
final_rnn_outputs = tf.gather_nd(rnn_outputs, final_indexes)
logits = self.output_embedding(final_rnn_outputs)
out = logits
out = (out, final_rnn_outputs, hidden_activation)
return out
return _call(inputs, training)
class LmLSTMSharedEmb(tf.keras.Model):
def __init__(self, hparams, scope="lm_lstm_shared_emb",*inputs, **kwargs):
del kwargs['cl_token']
super(LmLSTMSharedEmb, self).__init__()
self.rep_index = 3
self.rep_layer = -1
self.hparams = hparams
self.scope = scope
self.model_name = '_'.join([self.scope,
'em-'+str(self.hparams.embedding_dim),
'h-'+str(self.hparams.hidden_dim),
'd-'+str(self.hparams.depth),
'hdrop-'+str(self.hparams.hidden_dropout_rate),
'indrop-'+str(self.hparams.input_dropout_rate)])
self.regularizer = tf.keras.regularizers.l1_l2(l1=0.00,
l2=0.0000)
self.create_vars()
def create_vars(self):
@tf.function
def _create_vars():
self.input_embedding = SharedEmbeddings(vocab_size=self.hparams.input_dim,
hidden_size=self.hparams.embedding_dim,
initializer_range=self.hparams.initializer_range,
regularizer=self.regularizer,
name='embedding')
self.input_embedding_dropout = tf.keras.layers.Dropout(self.hparams.input_dropout_rate)
self.output_embedding_dropout = tf.keras.layers.Dropout(self.hparams.hidden_dropout_rate)
initializer_range = self.hparams.embedding_dim ** -0.5 if self.hparams.initializer_range is None else self.hparams.initializer_range
self.output_projection = tf.keras.layers.Dense(units=self.hparams.embedding_dim,
kernel_initializer=get_initializer(initializer_range))
self.stacked_rnns = []
self.rnn_initial_states = []
for _ in np.arange(self.hparams.depth):
initializer_range = self.hparams.hidden_dim ** -0.5 if self.hparams.initializer_range is None else self.hparams.initializer_range
self.stacked_rnns.append(tf.keras.layers.LSTM(units=self.hparams.hidden_dim,
return_sequences=True,
return_state=True,
go_backwards=False,
stateful=False,
unroll=False,
time_major=False,
recurrent_dropout=self.hparams.hidden_dropout_rate,
dropout=self.hparams.hidden_dropout_rate,
kernel_regularizer=self.regularizer,
recurrent_regularizer=self.regularizer,
bias_regularizer=self.regularizer,
kernel_initializer=get_initializer(initializer_range),
recurrent_initializer=get_initializer(initializer_range)
))
_create_vars()
initializer_range = self.hparams.hidden_dim ** -0.5 if self.hparams.initializer_range is None else self.hparams.initializer_range
for i in np.arange(self.hparams.depth):
state_size = self.stacked_rnns[i].cell.state_size
if nest.is_sequence(state_size):
init_state = nest.map_structure(lambda x: create_init_var(x, i, initializer_range), state_size)
else:
init_state = create_init_var(state_size, i, initializer_range)
self.rnn_initial_states.append(init_state)
def call(self, inputs, padding_symbol=tf.constant(0, dtype=tf.int64), **kwargs):
@tf.function(experimental_relax_shapes=True)
def _call(inputs, padding_symbol, **kwargs):
input_mask = tf.cast(inputs != padding_symbol, dtype=tf.bool)
embedded_input = self.input_embedding_dropout(self.input_embedding(inputs, mode='embedding'),
**kwargs)
rnn_outputs = embedded_input
for i in np.arange(self.hparams.depth):
batch_size_tensor = tf.shape(rnn_outputs)[0]
absl.logging.info(self.rnn_initial_states[i])
def tile_init(unnested_init_state):
return tf.tile(unnested_init_state, (batch_size_tensor, 1))
init_state = self.rnn_initial_states[i]
if nest.is_sequence(init_state):
init_for_batch = nest.map_structure(tile_init, init_state)
else:
init_for_batch = tile_init(init_state)
rnn_outputs, state_h, state_c = self.stacked_rnns[i](rnn_outputs, mask=input_mask,
initial_state=init_for_batch,
**kwargs)
rnn_outputs = self.output_projection(rnn_outputs, **kwargs)
rnn_outputs = self.output_embedding_dropout(rnn_outputs,**kwargs)
logits = self.input_embedding(rnn_outputs, mode='linear')
return logits
return _call(inputs, padding_symbol, **kwargs)
@tf.function(experimental_relax_shapes=True)
def detailed_call(self, inputs, padding_symbol=tf.constant(0, dtype=tf.int64), **kwargs):
@tf.function(experimental_relax_shapes=True)
def _call(inputs, padding_symbol, **kwargs):
input_mask = tf.cast(inputs != padding_symbol, dtype=tf.bool)
embedded_input = self.input_embedding_dropout(self.input_embedding(inputs, mode='embedding'),
**kwargs)
rnn_outputs = embedded_input
hidden_activation = [embedded_input]
for i in np.arange(self.hparams.depth):
batch_size_tensor = tf.shape(rnn_outputs)[0]
absl.logging.info(self.rnn_initial_states[i])
def tile_init(unnested_init_state):
return tf.tile(unnested_init_state, (batch_size_tensor, 1))
init_state = self.rnn_initial_states[i]
if nest.is_sequence(init_state):
init_for_batch = nest.map_structure(tile_init, init_state)
else:
init_for_batch = tile_init(init_state)
rnn_outputs, state_h, state_c = self.stacked_rnns[i](rnn_outputs, mask=input_mask,
initial_state=init_for_batch,
**kwargs)
hidden_activation.append(rnn_outputs)
rnn_outputs = self.output_projection(rnn_outputs, **kwargs)
rnn_outputs = self.output_embedding_dropout(rnn_outputs,**kwargs)
inputs_lengths = tf.reduce_sum(input_mask, axis=-1) - 1
batch_indices = tf.range(batch_size_tensor)
indices = tf.concat([batch_indices[..., None], inputs_lengths[..., None]], -1)
sentence_rep = tf.gather_nd(rnn_outputs, indices)
logits = self.input_embedding(rnn_outputs, mode='linear')
out = logits
out = (out,rnn_outputs, sentence_rep, hidden_activation)
return out
return _call(inputs, padding_symbol, **kwargs)
class LmLSTMSharedEmbV2(tf.keras.Model):
def __init__(self, hparams, scope="lm_lstm_shared_emb",*inputs, **kwargs):
del kwargs['cl_token']
super(LmLSTMSharedEmbV2, self).__init__()
self.rep_index = 3
self.rep_layer = -1
self.hparams = hparams
self.scope = scope
self.model_name = '_'.join([self.scope,
'em-'+str(self.hparams.embedding_dim),
'h-'+str(self.hparams.hidden_dim),
'd-'+str(self.hparams.depth),
'hdrop-'+str(self.hparams.hidden_dropout_rate),
'indrop-'+str(self.hparams.input_dropout_rate)])
self.regularizer = tf.keras.regularizers.l1_l2(l1=0.00,
l2=0.0000)
self.create_vars()
@tf.function
def create_vars(self):
self.input_embedding = SharedEmbeddings(vocab_size=self.hparams.input_dim,
hidden_size=self.hparams.embedding_dim,
initializer_range=self.hparams.initializer_range,
regularizer=self.regularizer,
name='embedding')
self.input_embedding_dropout = tf.keras.layers.Dropout(self.hparams.input_dropout_rate)
self.output_embedding_dropout = tf.keras.layers.Dropout(self.hparams.hidden_dropout_rate)
initializer_range = self.hparams.embedding_dim ** -0.5 if self.hparams.initializer_range is None else self.hparams.initializer_range
self.output_projection = tf.keras.layers.Dense(units=self.hparams.embedding_dim,
kernel_initializer=get_initializer(initializer_range))
self.stacked_rnns = []
self.rnn_initial_states = []
for _ in np.arange(self.hparams.depth):
initializer_range = self.hparams.hidden_dim ** -0.5 if self.hparams.initializer_range is None else self.hparams.initializer_range
self.stacked_rnns.append(tf.keras.layers.LSTM(units=self.hparams.hidden_dim,
return_sequences=True,
return_state=True,
go_backwards=False,
stateful=False,
unroll=False,
time_major=False,
recurrent_dropout=self.hparams.hidden_dropout_rate,
dropout=self.hparams.hidden_dropout_rate,
kernel_regularizer=self.regularizer,
recurrent_regularizer=self.regularizer,
bias_regularizer=self.regularizer,
kernel_initializer=get_initializer(initializer_range),
recurrent_initializer=get_initializer(initializer_range)
))
def call(self, inputs, padding_symbol=tf.constant(0, dtype=tf.int64), **kwargs):
@tf.function(experimental_relax_shapes=True)
def _call(inputs, padding_symbol, **kwargs):
input_mask = tf.cast(inputs != padding_symbol, dtype=tf.bool)
embedded_input = self.input_embedding_dropout(self.input_embedding(inputs, mode='embedding'),
**kwargs)
rnn_outputs = embedded_input
for i in np.arange(self.hparams.depth):
rnn_outputs, state_h, state_c = self.stacked_rnns[i](rnn_outputs, mask=input_mask,
**kwargs)
rnn_outputs = self.output_projection(rnn_outputs, **kwargs)
rnn_outputs = self.output_embedding_dropout(rnn_outputs,**kwargs)
logits = self.input_embedding(rnn_outputs, mode='linear')
return logits
return _call(inputs, padding_symbol, **kwargs)
@tf.function(experimental_relax_shapes=True)
def detailed_call(self, inputs, padding_symbol=tf.constant(0, dtype=tf.int64), **kwargs):
@tf.function(experimental_relax_shapes=True)
def _call(inputs, padding_symbol, **kwargs):
input_mask = tf.cast(inputs != padding_symbol, dtype=tf.bool)
embedded_input = self.input_embedding_dropout(self.input_embedding(inputs, mode='embedding'),
**kwargs)
rnn_outputs = embedded_input
hidden_activation = [embedded_input]
for i in np.arange(self.hparams.depth):
rnn_outputs, state_h, state_c = self.stacked_rnns[i](rnn_outputs, mask=input_mask,
**kwargs)
hidden_activation.append(rnn_outputs)
rnn_outputs = self.output_projection(rnn_outputs, **kwargs)
rnn_outputs = self.output_embedding_dropout(rnn_outputs,**kwargs)
batch_size_tensor = tf.shape(rnn_outputs)[0]
inputs_lengths = tf.reduce_sum(tf.cast(input_mask, dtype=tf.int32), axis=-1) - 1
batch_indices = tf.range(batch_size_tensor)
indices = tf.concat([batch_indices[..., None], inputs_lengths[..., None]], -1)
sentence_rep = tf.gather_nd(rnn_outputs, indices)
logits = self.input_embedding(rnn_outputs, mode='linear')
out = logits
out = (out, rnn_outputs, sentence_rep, hidden_activation)
return out
return _call(inputs, padding_symbol, **kwargs)
if __name__ == '__main__':
class hparams(object):
hidden_dim=8
input_dim=4
output_dim=4
depth=2
hidden_dropout_rate=0.1
lm_lstm = LmLSTM(hparams=hparams)
inputs = np.int64(np.flip(np.sort(np.random.uniform(0,3,size=(2,5)))))
inputs_mask = tf.equal(inputs, 0)
print(inputs_mask)
lm_lstm.build(input_shape=(None,None))
lm_lstm.summary()
print(inputs)
print(lm_lstm(inputs))
| 23,117 | 47.364017 | 138 | py |
Reflect | Reflect-master/tf2_models/transformers.py | import tensorflow as tf
from tf2_models.common_layers import get_initializer, shape_list
from tf2_models.embedding import SharedEmbeddings
from tf2_models.transformer_layers import Block
class GPT2(tf.keras.layers.Layer):
def __init__(self, hparams, *inputs, **kwargs):
super(GPT2, self).__init__(hparams, *inputs, **kwargs)
self.output_hidden_states = hparams.output_hidden_states
self.output_attentions = hparams.output_attentions
self.output_embeddings = hparams.output_embeddings
self.num_hidden_layers = hparams.depth
self.vocab_size = hparams.vocab_size
self.embedding_dim = hparams.embedding_dim
self.regularizer = tf.keras.regularizers.l1_l2(l1=0.00,
l2=0.0001)
self.create_vars(hparams)
@tf.function
def create_vars(self, hparams):
self.wte = SharedEmbeddings(self.vocab_size,
hparams.hidden_size,
initializer_range=hparams.initializer_range,
regularizer=self.regularizer,
name='wte')
self.wpe = tf.keras.layers.Embedding(hparams.n_positions,
hparams.embedding_dim,
embeddings_initializer=get_initializer(hparams.initializer_range),
embeddings_regularizer=self.regularizer,
name='wpe')
self.drop = tf.keras.layers.Dropout(hparams.embd_pdrop)
self.h = [Block(hparams.n_ctx,
hparams,
regularizer=self.regularizer,
scale=True,
name='h_._{}'.format(i)) for i in range(hparams.depth)]
self.ln_f = tf.keras.layers.LayerNormalization(epsilon=hparams.layer_norm_epsilon, name='ln_f')
def call(self, inputs, past=None, attention_mask=None, token_type_ids=None, position_ids=None,
training=False):
@tf.function(experimental_relax_shapes=True)
def _call(inputs, past, attention_mask, token_type_ids, position_ids,
training):
if past is None:
past_length = 0
past = [None] * len(self.h)
else:
past_length = shape_list(past[0][0])[-2]
if position_ids is None:
position_ids = tf.range(past_length, shape_list(inputs)[-1] + past_length, dtype=tf.int32)[tf.newaxis, :]
if attention_mask is not None:
attention_mask = attention_mask[:, tf.newaxis, tf.newaxis, :]
attention_mask = tf.cast(attention_mask, tf.float32)
attention_mask = (1.0 - attention_mask) * -10000.0
padding_mask = tf.cast(tf.not_equal(inputs, tf.zeros_like(inputs))[:,tf.newaxis,:,tf.newaxis],
dtype=tf.float32)
if attention_mask is None:
attention_mask = padding_mask
else:
attention_mask = attention_mask*padding_mask
input_shape = shape_list(inputs)
input_ids = tf.reshape(inputs, [-1, input_shape[-1]])
position_ids = tf.reshape(position_ids, [-1, shape_list(position_ids)[-1]])
inputs_embeds = self.wte(input_ids, mode='embedding')
position_embeds = self.wpe(position_ids)
if token_type_ids is not None:
token_type_ids = tf.reshape(token_type_ids, [-1, shape_list(token_type_ids)[-1]])
token_type_embeds = self.wte(token_type_ids, mode='embedding')
else:
token_type_embeds = 0
hidden_states = inputs_embeds + position_embeds + token_type_embeds
hidden_states = self.drop(hidden_states, training=training)
output_shape = input_shape + [shape_list(hidden_states)[-1]]
presents = ()
all_attentions = []
all_hidden_states = ()
for i, (block, layer_past) in enumerate(zip(self.h, past)):
if self.output_hidden_states:
all_hidden_states = all_hidden_states + (tf.reshape(hidden_states, output_shape),)
outputs = block([hidden_states, layer_past, attention_mask], training=training)
hidden_states, present = outputs[:2]
presents = presents + (present,)
if self.output_attentions:
all_attentions.append(outputs[2])
hidden_states = self.ln_f(hidden_states)
hidden_states = tf.reshape(hidden_states, output_shape)
# Add last hidden state
if self.output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
outputs = (hidden_states, presents)
if self.output_hidden_states:
outputs = outputs + (all_hidden_states,)
if self.output_attentions:
# let the number of heads free (-1) so we can extract attention even after head pruning
attention_output_shape = input_shape[:-1] + [-1] + shape_list(all_attentions[0])[-2:]
all_attentions = tuple(tf.reshape(t, attention_output_shape) for t in all_attentions)
outputs = outputs + (all_attentions,)
if self.output_embeddings:
outputs = outputs + (inputs_embeds,)
return outputs # last hidden state, presents, (all hidden_states), (attentions)
return _call(inputs, past, attention_mask, token_type_ids, position_ids,
training)
class GPT2SharedWeights(GPT2):
def __init__(self, hparams, *inputs, **kwargs):
super(GPT2SharedWeights, self).__init__(hparams, *inputs, **kwargs)
@tf.function
def create_vars(self, hparams):
self.wte = SharedEmbeddings(self.vocab_size ,
hparams.hidden_size,
initializer_range=hparams.initializer_range,
regularizer=self.regularizer,
name='wte')
self.wpe = tf.keras.layers.Embedding(hparams.n_positions,
hparams.embedding_dim,
embeddings_initializer=get_initializer(hparams.initializer_range),
embeddings_regularizer=self.regularizer,
name='wpe')
self.drop = tf.keras.layers.Dropout(hparams.embd_pdrop)
attention_block = Block(hparams.n_ctx,
hparams,
regularizer=self.regularizer,
scale=True,
name='h')
self.h = [attention_block for i in range(hparams.depth)]
self.ln_f = tf.keras.layers.LayerNormalization(epsilon=hparams.layer_norm_epsilon, name='ln_f')
class Bert(tf.keras.layers.Layer):
def __init__(self, hparams, *inputs, **kwargs):
super(Bert, self).__init__(hparams, *inputs, **kwargs)
self.output_hidden_states = hparams.output_hidden_states
self.output_attentions = hparams.output_attentions
self.output_embeddings = hparams.output_embeddings
self.num_hidden_layers = hparams.depth
self.vocab_size = hparams.vocab_size
self.embedding_dim = hparams.embedding_dim
self.regularizer = tf.keras.regularizers.l1_l2(l1=0.00,
l2=0.0001)
self.create_vars(hparams)
@tf.function
def create_vars(self, hparams):
self.wte = SharedEmbeddings(self.vocab_size,
hparams.hidden_size,
initializer_range=hparams.initializer_range,
regularizer=self.regularizer,
name='wte')
self.wpe = tf.keras.layers.Embedding(hparams.n_positions,
hparams.embedding_dim,
embeddings_initializer=get_initializer(hparams.initializer_range),
embeddings_regularizer=self.regularizer,
name='wpe')
self.drop = tf.keras.layers.Dropout(hparams.embd_pdrop)
self.h = [Block(hparams.n_ctx,
hparams,
regularizer=self.regularizer,
scale=True,
casual_masking=False,
name='h_._{}'.format(i)) for i in range(hparams.depth)]
self.ln_f = tf.keras.layers.LayerNormalization(epsilon=hparams.layer_norm_epsilon, name='ln_f')
def get_input_embeddings(self, inputs, past=None, attention_mask=None, token_type_ids=None, position_ids=None,
training=False):
if past is None:
past_length = 0
past = [None] * len(self.h)
else:
past_length = shape_list(past[0][0])[-2]
if position_ids is None:
position_ids = tf.range(past_length, shape_list(inputs)[-1] + past_length, dtype=tf.int32)[tf.newaxis, :]
input_shape = shape_list(inputs)
input_ids = tf.reshape(inputs, [-1, input_shape[-1]])
position_ids = tf.reshape(position_ids, [-1, shape_list(position_ids)[-1]])
inputs_embeds = self.wte(input_ids, mode='embedding')
position_embeds = self.wpe(position_ids)
if token_type_ids is not None:
token_type_ids = tf.reshape(token_type_ids, [-1, shape_list(token_type_ids)[-1]])
token_type_embeds = self.wte(token_type_ids, mode='embedding')
else:
token_type_embeds = 0
input_embeddings = inputs_embeds + position_embeds + token_type_embeds
padding_mask = tf.cast(tf.not_equal(inputs, tf.zeros_like(inputs))[:, tf.newaxis, :, tf.newaxis],
dtype=tf.float32)
return input_embeddings, input_shape, padding_mask, past
def call_with_embeddings(self, input_embeddings, input_shape, padding_mask, past, attention_mask=None,
training=False):
@tf.function(experimental_relax_shapes=True)
def _call(input_embeddings, input_shape, padding_mask, past, attention_mask,
training):
if attention_mask is not None:
attention_mask = attention_mask[:, tf.newaxis, tf.newaxis, :]
attention_mask = tf.cast(attention_mask, tf.float32)
attention_mask = (1.0 - attention_mask) * -10000.0
if attention_mask is None:
attention_mask = padding_mask
else:
attention_mask = attention_mask*padding_mask
hidden_states = input_embeddings
hidden_states = self.drop(hidden_states, training=training)
output_shape = input_shape + [shape_list(hidden_states)[-1]]
presents = ()
all_attentions = []
all_hidden_states = ()
for i, (block, layer_past) in enumerate(zip(self.h, past)):
if self.output_hidden_states:
all_hidden_states = all_hidden_states + (tf.reshape(hidden_states, output_shape),)
outputs = block([hidden_states, layer_past, attention_mask], training=training)
hidden_states, present = outputs[:2]
presents = presents + (present,)
if self.output_attentions:
all_attentions.append(outputs[2])
hidden_states = self.ln_f(hidden_states)
hidden_states = tf.reshape(hidden_states, output_shape)
# Add last hidden state
if self.output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
outputs = (hidden_states, presents)
if self.output_hidden_states:
outputs = outputs + (all_hidden_states,)
if self.output_attentions:
# let the number of heads free (-1) so we can extract attention even after head pruning
attention_output_shape = input_shape[:-1] + [-1] + shape_list(all_attentions[0])[-2:]
all_attentions = tuple(tf.reshape(t, attention_output_shape) for t in all_attentions)
outputs = outputs + (all_attentions,)
if self.output_embeddings:
outputs = outputs
return outputs # last hidden state, presents, (all hidden_states), (attentions), input_embedding
return _call(input_embeddings, input_shape, padding_mask, past, attention_mask,
training)
def call(self, inputs, past=None, attention_mask=None, token_type_ids=None, position_ids=None,
training=False):
@tf.function(experimental_relax_shapes=True)
def _call(inputs, past, attention_mask, token_type_ids, position_ids,
training):
if past is None:
past_length = 0
past = [None] * len(self.h)
else:
past_length = shape_list(past[0][0])[-2]
if position_ids is None:
position_ids = tf.range(past_length, shape_list(inputs)[-1] + past_length, dtype=tf.int32)[tf.newaxis, :]
if attention_mask is not None:
attention_mask = attention_mask[:, tf.newaxis, tf.newaxis, :]
attention_mask = tf.cast(attention_mask, tf.float32)
attention_mask = (1.0 - attention_mask) * -10000.0
padding_mask = tf.cast(tf.not_equal(inputs, tf.zeros_like(inputs))[:,tf.newaxis,:,tf.newaxis],
dtype=tf.float32)
if attention_mask is None:
attention_mask = padding_mask
else:
attention_mask = attention_mask*padding_mask
input_shape = shape_list(inputs)
input_ids = tf.reshape(inputs, [-1, input_shape[-1]])
position_ids = tf.reshape(position_ids, [-1, shape_list(position_ids)[-1]])
inputs_embeds = self.wte(input_ids, mode='embedding')
position_embeds = self.wpe(position_ids)
if token_type_ids is not None:
token_type_ids = tf.reshape(token_type_ids, [-1, shape_list(token_type_ids)[-1]])
token_type_embeds = self.wte(token_type_ids, mode='embedding')
else:
token_type_embeds = 0
hidden_states = inputs_embeds + position_embeds + token_type_embeds
hidden_states = self.drop(hidden_states, training=training)
output_shape = input_shape + [shape_list(hidden_states)[-1]]
presents = ()
all_attentions = []
all_hidden_states = ()
for i, (block, layer_past) in enumerate(zip(self.h, past)):
if self.output_hidden_states:
all_hidden_states = all_hidden_states + (tf.reshape(hidden_states, output_shape),)
outputs = block([hidden_states, layer_past, attention_mask], training=training)
hidden_states, present = outputs[:2]
presents = presents + (present,)
if self.output_attentions:
all_attentions.append(outputs[2])
hidden_states = self.ln_f(hidden_states)
hidden_states = tf.reshape(hidden_states, output_shape)
# Add last hidden state
if self.output_hidden_states:
all_hidden_states = all_hidden_states + (hidden_states,)
outputs = (hidden_states, presents)
if self.output_hidden_states:
outputs = outputs + (all_hidden_states,)
if self.output_attentions:
# let the number of heads free (-1) so we can extract attention even after head pruning
attention_output_shape = input_shape[:-1] + [-1] + shape_list(all_attentions[0])[-2:]
all_attentions = tuple(tf.reshape(t, attention_output_shape) for t in all_attentions)
outputs = outputs + (all_attentions,)
if self.output_embeddings:
outputs = outputs + (inputs_embeds,)
return outputs # last hidden state, presents, (all hidden_states), (attentions), input_embedding
return _call(inputs, past, attention_mask, token_type_ids, position_ids,
training)
class BertSharedWeights(Bert):
def __init__(self, hparams, *inputs, **kwargs):
super(BertSharedWeights, self).__init__(hparams, *inputs, **kwargs)
self.output_hidden_states = hparams.output_hidden_states
self.output_attentions = hparams.output_attentions
self.output_embeddings = hparams.output_embeddings
self.num_hidden_layers = hparams.depth
self.vocab_size = hparams.vocab_size
self.embedding_dim = hparams.embedding_dim
self.regularizer = tf.keras.regularizers.l1_l2(l1=0.00,
l2=0.0001)
self.create_vars(hparams)
@tf.function
def create_vars(self, hparams):
self.wte = SharedEmbeddings(self.vocab_size,
hparams.hidden_size,
initializer_range=hparams.initializer_range,
regularizer=self.regularizer,
name='wte')
self.wpe = tf.keras.layers.Embedding(hparams.n_positions,
hparams.embedding_dim,
embeddings_initializer=get_initializer(hparams.initializer_range),
embeddings_regularizer=self.regularizer,
name='wpe')
self.drop = tf.keras.layers.Dropout(hparams.embd_pdrop)
attention_block = Block(hparams.n_ctx,
hparams,
regularizer=self.regularizer,
scale=True,
casual_masking=False,
name='h')
self.h = [attention_block for i in range(hparams.depth)]
self.ln_f = tf.keras.layers.LayerNormalization(epsilon=hparams.layer_norm_epsilon, name='ln_f')
| 16,938 | 40.619165 | 113 | py |
Reflect | Reflect-master/tf2_models/resnet.py | import tensorflow as tf
class ResnetBlock(tf.keras.layers.Layer):
def __init__(self, filters, kernel_size, activation='relu',*inputs, **kwargs):
super(ResnetBlock, self).__init__(*inputs, **kwargs)
self.filters = filters
self.kernel_size = kernel_size
self.activation = activation
self.regularizer = tf.keras.regularizers.l1_l2(l1=0.00,
l2=0.000000002)
self.create_layer()
def create_layer(self):
self.conv1 = tf.keras.layers.Conv2D(self.filters, self.kernel_size,
activation=self.activation,
padding='same',
kernel_regularizer=self.regularizer)
self.batch_norm1 = tf.keras.layers.BatchNormalization()
self.conv2 = tf.keras.layers.Conv2D(self.filters, self.kernel_size,
activation=None,
padding='same',
kernel_regularizer=self.regularizer)
self.batch_norm2 = tf.keras.layers.BatchNormalization()
self.add = tf.keras.layers.Add()
self.activation = tf.keras.layers.Activation('relu')
def call(self, inputs, training=None, **kwargs):
outputs = self.conv1(inputs, training=training, **kwargs)
outputs = self.batch_norm1(outputs,training=training, **kwargs)
outputs = self.conv2(outputs, training=training, **kwargs)
outputs = self.batch_norm2(outputs,training=training, **kwargs)
outputs = self.add([outputs, inputs],training=training, **kwargs)
outputs = self.activation(outputs, training=training, **kwargs)
return outputs
class Resnet(tf.keras.Model):
def __init__(self, hparams, scope='resnet', *inputs, **kwargs):
if 'cl_token' in kwargs:
del kwargs['cl_token']
super(Resnet, self).__init__(name=scope, *inputs, **kwargs)
self.scope = scope
self.hparams = hparams
self.model_name = '_'.join([self.scope,
'h-' + str(self.hparams.hidden_dim),
'rd-' + str(self.hparams.num_res_net_blocks),
'hdrop-' + str(self.hparams.hidden_dropout_rate),
'indrop-' + str(self.hparams.input_dropout_rate)])
self.regularizer = tf.keras.regularizers.l1_l2(l1=0.00,
l2=0.000000002)
self.create_layers()
self.rep_index = 1
self.rep_layer = -1
def create_layers(self):
self.batch_norm1 = tf.keras.layers.BatchNormalization()
self.activation = tf.keras.layers.Activation('relu')
self.conv1 = tf.keras.layers.Conv2D(self.hparams.filters[0], self.hparams.kernel_size[0],
activation=None,
kernel_regularizer=self.regularizer)
self.batch_norm2 = tf.keras.layers.BatchNormalization()
self.conv2 = tf.keras.layers.Conv2D(self.hparams.filters[1], self.hparams.kernel_size[1],
activation=None,
kernel_regularizer=self.regularizer)
self.batch_norm3 = tf.keras.layers.BatchNormalization()
self.pool2 = tf.keras.layers.MaxPooling2D(self.hparams.pool_size)
self.resblocks = []
for i in range(self.hparams.num_res_net_blocks):
self.resblocks.append(ResnetBlock(self.hparams.filters[2], self.hparams.kernel_size[2]))
self.conv4 = tf.keras.layers.Conv2D(self.hparams.filters[3], self.hparams.kernel_size[3],
activation=None)
self.batch_norm4 = tf.keras.layers.BatchNormalization()
self.avgpool = tf.keras.layers.GlobalAveragePooling2D()
self.dense = tf.keras.layers.Dense(self.hparams.hidden_dim, activation='relu')
self.dropout = tf.keras.layers.Dropout(self.hparams.hidden_dropout_rate)
self.project = tf.keras.layers.Dense(self.hparams.output_dim, activation=None)
def call(self, inputs, padding_symbol=None, training=None, **kwargs):
x = inputs #self.batch_norm1(inputs, training=training, **kwargs)
x = self.conv1(x, training=training, **kwargs)
x = self.batch_norm2(x, training=training, **kwargs)
x = self.activation(x)
x = self.dropout(x, training=training, **kwargs)
x = self.conv2(x, training=training, **kwargs)
x = self.batch_norm3(x, training=training, **kwargs)
x = self.activation(x)
x = self.dropout(x, training=training, **kwargs)
x = self.pool2(x, training=training, **kwargs)
for i in range(self.hparams.num_res_net_blocks):
x = self.resblocks[i](x, training=training, **kwargs)
x = self.dropout(x, training=training, **kwargs)
x = self.conv4(x, training=training, **kwargs)
x = self.batch_norm4(x, training=training, **kwargs)
x = self.activation(x)
x = self.dropout(x, training=training, **kwargs)
x = self.avgpool(x, training=training, **kwargs)
x = self.dense(x, training=training, **kwargs)
x = self.dropout(x, training=training, **kwargs)
outputs = self.project(x, training=training, **kwargs)
return outputs
def detailed_call(self, inputs, padding_symbol=None, training=None, **kwargs):
self.layer_activations = []
x = self.batch_norm1(inputs, training=training, **kwargs)
x = self.conv1(x, training=training, **kwargs)
x = self.batch_norm2(x, training=training, **kwargs)
x = self.activation(x)
x = self.dropout(x, training=training, **kwargs)
self.layer_activations.append(x)
x = self.conv2(x, training=training, **kwargs)
x = self.batch_norm3(x, training=training, **kwargs)
x = self.activation(x)
x = self.dropout(x, training=training, **kwargs)
self.layer_activations.append(x)
x = self.pool2(x, training=training, **kwargs)
for i in range(self.hparams.num_res_net_blocks):
x = self.resblocks[i](x, training=training, **kwargs)
x = self.dropout(x, training=training, **kwargs)
self.layer_activations.append(x)
x = self.conv4(x, training=training, **kwargs)
x = self.batch_norm4(x, training=training, **kwargs)
x = self.activation(x)
x = self.dropout(x, training=training, **kwargs)
self.layer_activations.append(x)
x = self.avgpool(x, training=training, **kwargs)
x = self.dense(x, training=training, **kwargs)
x = self.dropout(x, training=training, **kwargs)
self.layer_activations.append(x)
pnltimt = x
outputs = self.project(x, training=training, **kwargs)
return outputs, pnltimt, self.layer_activations | 6,572 | 40.601266 | 94 | py |
Reflect | Reflect-master/tf2_models/cnn.py | import tensorflow as tf
import numpy as np
def max_out(inputs, num_units, axis=None):
shape = inputs.get_shape().as_list()
if shape[0] is None:
shape[0] = -1
if axis is None: # Assume that channel is the last dimension
axis = -1
num_channels = shape[axis]
if num_channels % num_units:
raise ValueError('number of features({}) is not '
'a multiple of num_units({})'.format(num_channels,
num_units))
shape[axis] = num_units
shape += [num_channels // num_units]
outputs = tf.reduce_max(tf.reshape(inputs, shape), -1)
return outputs
class VanillaCNN(tf.keras.models.Model):
def __init__(self, hparams, scope="cl_vcnn", *inputs, **kwargs):
if 'cl_token' in kwargs:
del kwargs['cl_token']
super(VanillaCNN, self).__init__(*inputs, **kwargs)
self.hparams = hparams
self.scope = scope
self.model_name = '_'.join([self.scope,
'hc-' + '.'.join(
[str(h) for h in self.hparams.filters]),
'hfc-' + '.'.join(
[str(h) for h in self.hparams.fc_dim]),
'd-' + str(self.hparams.depth),
'hdrop-' + str(
self.hparams.hidden_dropout_rate),
'indrop-' + str(
self.hparams.input_dropout_rate)])
self.regularizer = tf.keras.regularizers.l1_l2(l1=0.00,
l2=0.000000002)
self.create_vars()
self.rep_index = 1
self.rep_layer = -1
def create_vars(self):
self.indrop = tf.keras.layers.Dropout(rate=self.hparams.input_dropout_rate)
self.cnns = []
self.cnn_nns = []
self.cnn_bnz = []
self.cnn_activations = []
self.cnn_pooling = []
self.cnn_dropouts = []
for i in np.arange(self.hparams.depth):
self.cnns.append(tf.keras.layers.Conv2D(self.hparams.filters[i],
self.hparams.kernel_size[i],
activation=None,
kernel_regularizer=self.regularizer))
# if self.hparams.maxout_size[i] < self.hparams.filters[i]:
# nn_size = int(self.hparams.filters[i] / self.hparams.maxout_size[i])
# self.cnn_nns.append(tf.keras.layers.Conv2D(self.hparams.maxout_size[i],
# (1,1),
# activation=None,
# kernel_regularizer=self.regularizer))
# else:
# self.cnn_nns.append(tf.keras.layers.Lambda(lambda x: x))
self.cnn_bnz.append(tf.keras.layers.BatchNormalization())
self.cnn_activations.append(tf.keras.layers.Activation('relu'))
self.cnn_pooling.append(
tf.keras.layers.MaxPooling2D(self.hparams.pool_size[i]))
self.cnn_dropouts.append(
tf.keras.layers.Dropout(rate=self.hparams.hidden_dropout_rate))
self.avg_pool = tf.keras.layers.GlobalAveragePooling2D()
self.densez = []
self.dense_bnz = []
self.dense_activations = []
self.dense_dropouts = []
for i in np.arange(self.hparams.proj_depth):
self.densez.append(
tf.keras.layers.Dense(self.hparams.fc_dim[i], activation=None,
kernel_regularizer=self.regularizer))
self.dense_bnz.append(tf.keras.layers.BatchNormalization())
self.dense_activations.append(tf.keras.layers.Activation('relu'))
self.dense_dropouts.append(
tf.keras.layers.Dropout(rate=self.hparams.hidden_dropout_rate))
self.projector = tf.keras.layers.Dense(self.hparams.output_dim,
kernel_regularizer=self.regularizer)
def call(self, inputs, padding_symbol=None, training=None, **kwargs):
x = self.indrop(inputs, training=training, **kwargs)
for i in np.arange(self.hparams.depth):
x = self.cnns[i](x, training=training, **kwargs)
# x = self.cnn_nns[i](x, training=training, **kwargs)
x = max_out(x, self.hparams.maxout_size[i])
x = self.cnn_bnz[i](x, training=training, **kwargs)
x = self.cnn_activations[i](x, training=training, **kwargs)
x = self.cnn_pooling[i](x, training=training, **kwargs)
x = self.cnn_dropouts[i](x, training=training, **kwargs)
x = self.avg_pool(x, **kwargs)
for i in np.arange(self.hparams.proj_depth):
x = self.densez[i](x, training=training, **kwargs)
x = self.dense_bnz[i](x, training=training, **kwargs)
x = self.dense_activations[i](x, training=training, **kwargs)
x = self.dense_dropouts[i](x, training=training, **kwargs)
logits = self.projector(x, training=training, **kwargs)
return logits
def detailed_call(self, inputs, padding_symbol=None, **kwargs):
x = self.indrop(inputs)
hidden_activations = []
for i in np.arange(self.hparams.depth):
x = self.cnns[i](x, **kwargs)
x = max_out(x, self.hparams.maxout_size[i])
x = self.cnn_bnz[i](x, **kwargs)
x = self.cnn_activations[i](x, **kwargs)
x = self.cnn_pooling[i](x, **kwargs)
x = self.cnn_dropouts[i](x, **kwargs)
hidden_activations.append(x)
x = self.avg_pool(x, **kwargs)
hidden_activations.append(x)
for i in np.arange(self.hparams.proj_depth):
x = self.densez[i](x, **kwargs)
x = self.dense_bnz[i](x, **kwargs)
x = self.dense_activations[i](x, **kwargs)
x = self.dense_dropouts[i](x, **kwargs)
hidden_activations.append(x)
logits = self.projector(x, **kwargs)
return logits, hidden_activations[-1], hidden_activations
| 5,878 | 38.993197 | 91 | py |
Reflect | Reflect-master/tf2_models/utils.py | import tensorflow as tf
import re
from tensorboard.compat.tensorflow_stub import tensor_shape
def camel2snake(name):
return name[0].lower() + re.sub(r'(?!^)[A-Z]', lambda x: '_' + x.group(0).lower(), name[1:])
def log_summary(log_value, log_name, summary_scope):
"""Produce scalar summaries."""
with tf.compat.v2.summary.experimental.summary_scope(summary_scope):
tf.summary.scalar(log_name, log_value)
def create_init_var(unnested_state_size, i, initializer_range):
flat_dims = tensor_shape.as_shape(unnested_state_size).as_list()
init_state_size = [1] + flat_dims
return tf.Variable(shape=init_state_size, dtype=tf.float32,
initial_value=tf.keras.initializers.TruncatedNormal(stddev=initializer_range)(
shape=init_state_size),
trainable=True,
name="lstm_init_" + str(i))
| 884 | 31.777778 | 99 | py |
Reflect | Reflect-master/tf2_models/train_utils.py | import absl
import tensorflow as tf
from tensorflow.python.framework import ops
from tensorflow.python.keras.optimizer_v2.learning_rate_schedule import LearningRateSchedule
from tensorflow.python.ops import math_ops
from tensorflow.python.util.tf_export import keras_export
from tensorflow_addons.utils import keras_utils
@keras_export("keras.optimizers.schedules.ExponentialDecay")
class ExponentialDecayWithWarmpUp(LearningRateSchedule):
"""A LearningRateSchedule that uses an exponential decay schedule."""
def __init__(
self,
initial_learning_rate,
decay_steps,
decay_rate,
warmup_steps,
warmup_learning_rate=0.0,
hold_base_rate_steps=0,
staircase=False,
name=None):
"""Applies exponential decay to the learning rate.
When training a model, it is often recommended to lower the learning rate as
the training progresses. This schedule applies an exponential decay function
to an optimizer step, given a provided initial learning rate.
The schedule a 1-arg callable that produces a decayed learning
rate when passed the current optimizer step. This can be useful for changing
the learning rate value across different invocations of optimizer functions.
It is computed as:
```python
def decayed_learning_rate(step):
return initial_learning_rate * decay_rate ^ (step / decay_steps)
```
If the argument `staircase` is `True`, then `step / decay_steps` is
an integer division and the decayed learning rate follows a
staircase function.
You can pass this schedule directly into a `tf.keras.optimizers.Optimizer`
as the learning rate.
Example: When fitting a Keras model, decay every 100000 steps with a base
of 0.96:
```python
initial_learning_rate = 0.1
lr_schedule = tf.keras.optimizers.schedules.ExponentialDecay(
initial_learning_rate,
decay_steps=100000,
decay_rate=0.96,
staircase=True)
model.compile(optimizer=tf.keras.optimizers.SGD(learning_rate=lr_schedule),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
model.fit(data, labels, epochs=5)
```
The learning rate schedule is also serializable and deserializable using
`tf.keras.optimizers.schedules.serialize` and
`tf.keras.optimizers.schedules.deserialize`.
Args:
initial_learning_rate: A scalar `float32` or `float64` `Tensor` or a
Python number. The initial learning rate.
decay_steps: A scalar `int32` or `int64` `Tensor` or a Python number.
Must be positive. See the decay computation above.
decay_rate: A scalar `float32` or `float64` `Tensor` or a
Python number. The decay rate.
staircase: Boolean. If `True` decay the learning rate at discrete
intervals
name: String. Optional name of the operation. Defaults to
'ExponentialDecay'.
Returns:
A 1-arg callable learning rate schedule that takes the current optimizer
step and outputs the decayed learning rate, a scalar `Tensor` of the same
type as `initial_learning_rate`.
"""
super(ExponentialDecayWithWarmpUp, self).__init__()
self.initial_learning_rate = initial_learning_rate
self.decay_steps = decay_steps
self.decay_rate = decay_rate
self.warmup_steps = warmup_steps
self.warmup_learning_rate = warmup_learning_rate
self.hold_base_rate_steps = hold_base_rate_steps
self.staircase = staircase
self.name = name
@tf.function(experimental_relax_shapes=True)
def __call__(self, step):
with ops.name_scope_v2(self.name or "ExponentialDecay") as name:
initial_learning_rate = tf.constant(
self.initial_learning_rate, name="initial_learning_rate", dtype=tf.float32)
warmup_learning_rate = tf.constant(
self.warmup_learning_rate, name="warmup_learning_rate", dtype=tf.float32)
dtype = initial_learning_rate.dtype
decay_steps = math_ops.cast(self.decay_steps, dtype)
decay_rate = math_ops.cast(self.decay_rate, dtype)
warmup_steps = math_ops.cast(self.warmup_steps, dtype)
hold_base_rate_steps = math_ops.cast(self.hold_base_rate_steps, dtype)
global_step_recomp = math_ops.cast(step, dtype)
p = (global_step_recomp - (warmup_steps+hold_base_rate_steps)) / (decay_steps)
if self.staircase:
p = math_ops.floor(p)
learning_rate= math_ops.multiply(
initial_learning_rate, math_ops.pow(decay_rate, p), name=name)
learning_rate = tf.where(
global_step_recomp > (warmup_steps + hold_base_rate_steps),
learning_rate, initial_learning_rate)
if self.warmup_steps > 0:
if self.initial_learning_rate < self.warmup_learning_rate:
raise ValueError('learning_rate_base must be larger or equal to '
'warmup_learning_rate.')
slope = (initial_learning_rate - warmup_learning_rate) / warmup_steps
warmup_rate = slope * tf.cast(global_step_recomp,
tf.float32) + warmup_learning_rate
learning_rate = tf.where(global_step_recomp < warmup_steps, warmup_rate,
learning_rate)
return learning_rate
def get_config(self):
return {
"initial_learning_rate": self.initial_learning_rate,
"decay_steps": self.decay_steps,
"decay_rate": self.decay_rate,
"staircase": self.staircase,
"warmup_steps": self.warmup_steps,
"warmup_learning_rate": self.warmup_learning_rate,
"hold_base_rate_steps": self.hold_base_rate_steps,
"name": self.name
}
class RectifiedAdam(tf.keras.optimizers.Optimizer):
"""Variant of the Adam optimizer whose adaptive learning rate is rectified
so as to have a consistent variance.
It implements the Rectified Adam (a.k.a. RAdam) proposed by
Liyuan Liu et al. in [On The Variance Of The Adaptive Learning Rate
And Beyond](https://arxiv.org/pdf/1908.03265v1.pdf).
Example of usage:
```python
opt = tfa.optimizers.RectifiedAdam(lr=1e-3)
```
Note: `amsgrad` is not described in the original paper. Use it with
caution.
RAdam is not a placement of the heuristic warmup, the settings should be
kept if warmup has already been employed and tuned in the baseline method.
You can enable warmup by setting `total_steps` and `warmup_proportion`:
```python
opt = tfa.optimizers.RectifiedAdam(
lr=1e-3,
total_steps=10000,
warmup_proportion=0.1,
min_lr=1e-5,
)
```
In the above example, the learning rate will increase linearly
from 0 to `lr` in 1000 steps, then decrease linearly from `lr` to `min_lr`
in 9000 steps.
Lookahead, proposed by Michael R. Zhang et.al in the paper
[Lookahead Optimizer: k steps forward, 1 step back]
(https://arxiv.org/abs/1907.08610v1), can be integrated with RAdam,
which is announced by Less Wright and the new combined optimizer can also
be called "Ranger". The mechanism can be enabled by using the lookahead
wrapper. For example:
```python
radam = tfa.optimizers.RectifiedAdam()
ranger = tfa.optimizers.Lookahead(radam, sync_period=6, slow_step_size=0.5)
```
"""
def __init__(self,
learning_rate=0.001,
beta_1=0.9,
beta_2=0.999,
epsilon=1e-7,
weight_decay=0.,
amsgrad=False,
sma_threshold=5.0,
total_steps=0,
warmup_proportion=0.1,
min_lr=0.,
name='RectifiedAdam',
**kwargs):
r"""Construct a new RAdam optimizer.
Args:
learning_rate: A Tensor or a floating point value.
The learning rate.
beta_1: A float value or a constant float tensor.
The exponential decay rate for the 1st moment estimates.
beta_2: A float value or a constant float tensor.
The exponential decay rate for the 2nd moment estimates.
epsilon: A small constant for numerical stability.
weight_decay: A floating point value. Weight decay for each param.
amsgrad: boolean. Whether to apply AMSGrad variant of this
algorithm from the paper "On the Convergence of Adam and
beyond".
sma_threshold. A float value.
The threshold for simple mean average.
total_steps: An integer. Total number of training steps.
Enable warmup by setting a positive value.
warmup_proportion: A floating point value.
The proportion of increasing steps.
min_lr: A floating point value. Minimum learning rate after warmup.
name: Optional name for the operations created when applying
gradients. Defaults to "RectifiedAdam".
**kwargs: keyword arguments. Allowed to be {`clipnorm`,
`clipvalue`, `lr`, `decay`}. `clipnorm` is clip gradients
by norm; `clipvalue` is clip gradients by value, `decay` is
included for backward compatibility to allow time inverse
decay of learning rate. `lr` is included for backward
compatibility, recommended to use `learning_rate` instead.
"""
super(RectifiedAdam, self).__init__(name, **kwargs)
self._set_hyper('learning_rate', kwargs.get('lr', learning_rate))
self._set_hyper('beta_1', beta_1)
self._set_hyper('beta_2', beta_2)
self._set_hyper('decay', self._initial_decay)
self._set_hyper('weight_decay', weight_decay)
self._set_hyper('sma_threshold', sma_threshold)
self._set_hyper('total_steps', float(total_steps))
self._set_hyper('warmup_proportion', warmup_proportion)
self._set_hyper('min_lr', min_lr)
self.epsilon = epsilon or tf.keras.backend.epsilon()
self.amsgrad = amsgrad
self._initial_weight_decay = weight_decay
self._initial_total_steps = total_steps
def _create_slots(self, var_list):
for var in var_list:
self.add_slot(var, 'm')
for var in var_list:
self.add_slot(var, 'v')
if self.amsgrad:
for var in var_list:
self.add_slot(var, 'vhat')
def set_weights(self, weights):
params = self.weights
num_vars = int((len(params) - 1) / 2)
if len(weights) == 3 * num_vars + 1:
weights = weights[:len(params)]
super(RectifiedAdam, self).set_weights(weights)
def _resource_apply_dense(self, grad, var):
var_dtype = var.dtype.base_dtype
lr_t = self._decayed_lr(var_dtype)
m = self.get_slot(var, 'm')
v = self.get_slot(var, 'v')
beta_1_t = self._get_hyper('beta_1', var_dtype)
beta_2_t = self._get_hyper('beta_2', var_dtype)
epsilon_t = tf.convert_to_tensor(self.epsilon, var_dtype)
local_step = tf.cast(self.iterations + 1, var_dtype)
beta_1_power = tf.pow(beta_1_t, local_step)
beta_2_power = tf.pow(beta_2_t, local_step)
if self._initial_total_steps > 0:
total_steps = self._get_hyper('total_steps', var_dtype)
warmup_steps = total_steps *\
self._get_hyper('warmup_proportion', var_dtype)
min_lr = self._get_hyper('min_lr', var_dtype)
decay_steps = tf.maximum(total_steps - warmup_steps, 1)
decay_rate = (min_lr - lr_t) / decay_steps
lr_t = tf.where(
local_step <= warmup_steps,
lr_t * (local_step / warmup_steps),
lr_t + decay_rate * tf.minimum(local_step - warmup_steps,
decay_steps),
)
sma_inf = 2.0 / (1.0 - beta_2_t) - 1.0
sma_t = sma_inf - 2.0 * local_step * beta_2_power / (
1.0 - beta_2_power)
m_t = m.assign(
beta_1_t * m + (1.0 - beta_1_t) * grad,
use_locking=self._use_locking)
m_corr_t = m_t / (1.0 - beta_1_power)
v_t = v.assign(
beta_2_t * v + (1.0 - beta_2_t) * tf.square(grad),
use_locking=self._use_locking)
if self.amsgrad:
vhat = self.get_slot(var, 'vhat')
vhat_t = vhat.assign(
tf.maximum(vhat, v_t), use_locking=self._use_locking)
v_corr_t = tf.sqrt(vhat_t / (1.0 - beta_2_power))
else:
vhat_t = None
v_corr_t = tf.sqrt(v_t / (1.0 - beta_2_power))
r_t = tf.sqrt((sma_t - 4.0) / (sma_inf - 4.0) * (sma_t - 2.0) /
(sma_inf - 2.0) * sma_inf / sma_t)
sma_threshold = self._get_hyper('sma_threshold', var_dtype)
var_t = tf.where(sma_t >= sma_threshold,
r_t * m_corr_t / (v_corr_t + epsilon_t), m_corr_t)
if self._initial_weight_decay > 0.0:
var_t += self._get_hyper('weight_decay', var_dtype) * var
var_update = var.assign_sub(
lr_t * var_t, use_locking=self._use_locking)
updates = [var_update, m_t, v_t]
if self.amsgrad:
updates.append(vhat_t)
return tf.group(*updates)
def _resource_apply_sparse(self, grad, var, indices):
var_dtype = var.dtype.base_dtype
lr_t = self._decayed_lr(var_dtype)
beta_1_t = self._get_hyper('beta_1', var_dtype)
beta_2_t = self._get_hyper('beta_2', var_dtype)
epsilon_t = tf.convert_to_tensor(self.epsilon, var_dtype)
local_step = tf.cast(self.iterations + 1, var_dtype)
beta_1_power = tf.pow(beta_1_t, local_step)
beta_2_power = tf.pow(beta_2_t, local_step)
if self._initial_total_steps > 0:
total_steps = self._get_hyper('total_steps', var_dtype)
warmup_steps = total_steps *\
self._get_hyper('warmup_proportion', var_dtype)
min_lr = self._get_hyper('min_lr', var_dtype)
decay_steps = tf.maximum(total_steps - warmup_steps, 1)
decay_rate = (min_lr - lr_t) / decay_steps
lr_t = tf.where(
local_step <= warmup_steps,
lr_t * (local_step / warmup_steps),
lr_t + decay_rate * tf.minimum(local_step - warmup_steps,
decay_steps),
)
sma_inf = 2.0 / (1.0 - beta_2_t) - 1.0
sma_t = sma_inf - 2.0 * local_step * beta_2_power / (
1.0 - beta_2_power)
m = self.get_slot(var, 'm')
m_scaled_g_values = grad * (1 - beta_1_t)
m_t = m.assign(m * beta_1_t, use_locking=self._use_locking)
with tf.control_dependencies([m_t]):
m_t = self._resource_scatter_add(m, indices, m_scaled_g_values)
m_corr_t = m_t / (1.0 - beta_1_power)
v = self.get_slot(var, 'v')
v_scaled_g_values = (grad * grad) * (1 - beta_2_t)
v_t = v.assign(v * beta_2_t, use_locking=self._use_locking)
with tf.control_dependencies([v_t]):
v_t = self._resource_scatter_add(v, indices, v_scaled_g_values)
if self.amsgrad:
vhat = self.get_slot(var, 'vhat')
vhat_t = vhat.assign(
tf.maximum(vhat, v_t), use_locking=self._use_locking)
v_corr_t = tf.sqrt(vhat_t / (1.0 - beta_2_power))
else:
vhat_t = None
v_corr_t = tf.sqrt(v_t / (1.0 - beta_2_power))
r_t = tf.sqrt((sma_t - 4.0) / (sma_inf - 4.0) * (sma_t - 2.0) /
(sma_inf - 2.0) * sma_inf / sma_t)
sma_threshold = self._get_hyper('sma_threshold', var_dtype)
var_t = tf.where(sma_t >= sma_threshold,
r_t * m_corr_t / (v_corr_t + epsilon_t), m_corr_t)
if self._initial_weight_decay > 0.0:
var_t += self._get_hyper('weight_decay', var_dtype) * var
with tf.control_dependencies([var_t]):
var_update = self._resource_scatter_add(
var, indices, tf.gather(-lr_t * var_t, indices))
updates = [var_update, m_t, v_t]
if self.amsgrad:
updates.append(vhat_t)
return tf.group(*updates)
def get_config(self):
config = super(RectifiedAdam, self).get_config()
config.update({
'learning_rate':
self._serialize_hyperparameter('learning_rate'),
'beta_1':
self._serialize_hyperparameter('beta_1'),
'beta_2':
self._serialize_hyperparameter('beta_2'),
'decay':
self._serialize_hyperparameter('decay'),
'weight_decay':
self._serialize_hyperparameter('weight_decay'),
'sma_threshold':
self._serialize_hyperparameter('sma_threshold'),
'epsilon':
self.epsilon,
'amsgrad':
self.amsgrad,
'total_steps':
self._serialize_hyperparameter('total_steps'),
'warmup_proportion':
self._serialize_hyperparameter('warmup_proportion'),
'min_lr':
self._serialize_hyperparameter('min_lr'),
})
return config | 17,416 | 40.568019 | 92 | py |
Reflect | Reflect-master/tf2_models/transformer_layers.py | import tensorflow as tf
from tf2_models.common_layers import get_initializer, shape_list, gelu
class Attention(tf.keras.layers.Layer):
def __init__(self, hidden_dim, n_ctx, config, regularizer, casual_masking=True, scale=False, **kwargs):
super(Attention, self).__init__(**kwargs)
self.output_attentions = config.output_attentions
self.casual_masking = casual_masking
n_state = hidden_dim
assert n_state % config.n_head == 0
self.n_ctx = n_ctx
self.n_head = config.n_head
self.split_size = n_state
self.scale = scale
self.regularizer = regularizer
self.c_attn = Conv1D(nf=n_state * 3, nx=hidden_dim,
initializer_range=config.initializer_range,
regularizer=self.regularizer, name='c_attn')
self.c_proj = Conv1D(nf=n_state, nx=hidden_dim,
initializer_range=config.initializer_range,
regularizer=self.regularizer,
name='c_proj')
self.attn_dropout = tf.keras.layers.Dropout(config.attn_pdrop)
self.resid_dropout = tf.keras.layers.Dropout(config.resid_pdrop)
@staticmethod
def causal_attention_mask(nd, ns, dtype):
"""1's in the lower triangle, counting from the lower right corner.
Same as tf.matrix_band_part(tf.ones([nd, ns]), -1, ns-nd), but doesn't produce garbage on TPUs.
"""
i = tf.range(nd)[:, None]
j = tf.range(ns)
m = i >= j - ns + nd
return tf.cast(m, dtype)
def _attn(self, inputs, training=False):
q, k, v, attention_mask = inputs
# q, k, v have shape [batch, heads, sequence, features]
w = tf.matmul(q, k, transpose_b=True)
if self.scale:
dk = tf.cast(tf.shape(k)[-1], tf.float32) # scale attention_scores
w = w / tf.math.sqrt(dk)
# w has shape [batch, heads, dst_sequence, src_sequence], where information flows from src to dst.
_, _, nd, ns = shape_list(w)
if self.casual_masking:
b = self.causal_attention_mask(nd, ns, dtype=w.dtype)
b = tf.reshape(b, [1, 1, nd, ns])
w = w * b - 1e4 * (1 - b)
if attention_mask is not None:
# Apply the attention mask
w = w + attention_mask
w = tf.nn.softmax(w, axis=-1)
w = self.attn_dropout(w, training=training)
outputs = [tf.matmul(w, v)]
if self.output_attentions:
outputs.append(w)
return outputs
def merge_heads(self, x):
x = tf.transpose(x, [0, 2, 1, 3])
x_shape = shape_list(x)
new_x_shape = x_shape[:-2] + [x_shape[-2] * x_shape[-1]]
return tf.reshape(x, new_x_shape)
def split_heads(self, x):
x_shape = shape_list(x)
new_x_shape = x_shape[:-1] + [self.n_head, x_shape[-1] // self.n_head]
x = tf.reshape(x, new_x_shape)
return tf.transpose(x, (0, 2, 1, 3)) # (batch, head, seq_length, head_features)
def call(self, inputs, training=False):
x, layer_past, attention_mask = inputs
x = self.c_attn(x)
query, key, value = tf.split(x, 3, axis=2)
query = self.split_heads(query)
key = self.split_heads(key)
value = self.split_heads(value)
if layer_past is not None:
past_key, past_value = tf.unstack(layer_past, axis=1)
key = tf.concat([past_key, key], axis=-2)
value = tf.concat([past_value, value], axis=-2)
present = tf.stack([key, value], axis=1)
attn_outputs = self._attn([query, key, value, attention_mask], training=training)
a = attn_outputs[0]
a = self.merge_heads(a)
a = self.c_proj(a)
a = self.resid_dropout(a, training=training)
outputs = [a, present] + attn_outputs[1:]
return outputs # a, present, (attentions)
class Conv1D(tf.keras.layers.Layer):
def __init__(self, nf, nx, regularizer, initializer_range=0.02, **kwargs):
""" TFConv1D layer as defined by Radford et al. for OpenAI GPT (and also used in GPT-2)
Basically works like a Linear layer but the weights are transposed
"""
super(Conv1D, self).__init__(**kwargs)
self.nf = nf
self.nx = nx
self.initializer_range = initializer_range
self.regularizer = regularizer
def build(self, input_shape):
self.weight = self.add_weight(
"weight",
shape=[self.nx, self.nf],
initializer=get_initializer(self.initializer_range),
regularizer=self.regularizer)
self.bias = self.add_weight(
"bias",
shape=[1, self.nf],
initializer=tf.zeros_initializer(),
regularizer=self.regularizer)
def call(self, x, **kwargs):
bz, sl = shape_list(x)[:2]
x = tf.reshape(x, [-1, self.nx])
x = tf.matmul(x, self.weight) + self.bias
x = tf.reshape(x, [bz, sl, self.nf])
return x
class Block(tf.keras.layers.Layer):
def __init__(self, n_ctx, config, regularizer, casual_masking=True, scale=False, **kwargs):
super(Block, self).__init__(**kwargs)
self.regularizer = regularizer
nx = config.embedding_dim
self.ln_1 = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_epsilon, name='ln_1')
self.attn = Attention(hidden_dim=nx, n_ctx=n_ctx, config=config, scale=scale,
regularizer=self.regularizer,
casual_masking=casual_masking, name='attn')
self.ln_2 = tf.keras.layers.LayerNormalization(epsilon=config.layer_norm_epsilon, name='ln_2')
self.mlp = TransformerMLP(4 * nx, config, regularizer=self.regularizer, name='mlp')
def call(self, inputs, training=False):
x, layer_past, attention_mask = inputs
a = self.ln_1(x)
output_attn = self.attn([a, layer_past, attention_mask], training=training)
a = output_attn[0] # output_attn: a, present, (attentions)
x = x + a
m = self.ln_2(x)
m = self.mlp(m, training=training)
x = x + m
outputs = [x] + output_attn[1:]
return outputs # x, present, (attentions)
class TransformerMLP(tf.keras.layers.Layer):
def __init__(self, n_state, config, regularizer, **kwargs):
super(TransformerMLP, self).__init__(**kwargs)
self.regularizer = regularizer
nx = config.embedding_dim
self.c_fc = Conv1D(n_state, nx, initializer_range=config.initializer_range,
regularizer=self.regularizer, name='c_fc')
self.c_proj = Conv1D(nx, n_state, initializer_range=config.initializer_range,
regularizer=self.regularizer, name='c_proj')
self.act = gelu
self.dropout = tf.keras.layers.Dropout(config.resid_pdrop)
def call(self, x, training=False):
h = self.act(self.c_fc(x))
h2 = self.c_proj(h)
h2 = self.dropout(h2, training=training)
return h2 | 6,560 | 35.049451 | 105 | py |
Reflect | Reflect-master/tf2_models/ff_resnet.py | import tensorflow as tf
class FFResnetBlock(tf.keras.layers.Layer):
def __init__(self, filters, kernel_size, activation='relu',*inputs, **kwargs):
super(FFResnetBlock, self).__init__(*inputs, **kwargs)
self.filters = filters
self.kernel_size = kernel_size
self.activation = activation
self.regularizer = tf.keras.regularizers.l1_l2(l1=0.00,
l2=0.000000002)
self.create_layer()
def create_layer(self):
self.conv1 = tf.keras.layers.Dense(self.filters*9,
activation=self.activation,
kernel_regularizer=self.regularizer)
self.batch_norm1 = tf.keras.layers.BatchNormalization()
self.conv2 = tf.keras.layers.Dense(self.filters*9,
activation=None,
kernel_regularizer=self.regularizer)
self.batch_norm2 = tf.keras.layers.BatchNormalization()
self.add = tf.keras.layers.Add()
self.activation = tf.keras.layers.Activation('relu')
def call(self, inputs, training=None, **kwargs):
outputs = self.conv1(inputs, training=training, **kwargs)
outputs = self.batch_norm1(outputs,training=training, **kwargs)
outputs = self.conv2(outputs, training=training, **kwargs)
outputs = self.batch_norm2(outputs,training=training, **kwargs)
outputs = self.add([outputs, inputs],training=training, **kwargs)
outputs = self.activation(outputs, training=training, **kwargs)
return outputs
class FFResnet(tf.keras.Model):
def __init__(self, hparams, scope='ff_resnet', *inputs, **kwargs):
if 'cl_token' in kwargs:
del kwargs['cl_token']
super(FFResnet, self).__init__(name=scope, *inputs, **kwargs)
self.scope = scope
self.hparams = hparams
self.model_name = '_'.join([self.scope,
'h-' + str(self.hparams.hidden_dim),
'rd-' + str(self.hparams.num_res_net_blocks),
'hdrop-' + str(self.hparams.hidden_dropout_rate),
'indrop-' + str(self.hparams.input_dropout_rate)])
self.regularizer = tf.keras.regularizers.l1_l2(l1=0.00,
l2=0.000000002)
self.create_layers()
self.rep_index = 1
self.rep_layer = -1
def create_layers(self):
self.flat = tf.keras.layers.Flatten()
self.batch_norm1 = tf.keras.layers.BatchNormalization()
self.activation = tf.keras.layers.Activation('relu')
self.conv1 = tf.keras.layers.Dense(self.hparams.filters[0]*9,
activation=None,
kernel_regularizer=self.regularizer)
self.batch_norm2 = tf.keras.layers.BatchNormalization()
self.conv2 = tf.keras.layers.Dense(self.hparams.filters[1]*9,
activation=None,
kernel_regularizer=self.regularizer)
self.batch_norm3 = tf.keras.layers.BatchNormalization()
self.resblocks = []
for i in range(self.hparams.num_res_net_blocks):
self.resblocks.append(FFResnetBlock(self.hparams.filters[2], self.hparams.kernel_size[2]))
self.conv4 = tf.keras.layers.Dense(self.hparams.filters[3]*9,
activation=None)
self.batch_norm4 = tf.keras.layers.BatchNormalization()
self.dense = tf.keras.layers.Dense(self.hparams.hidden_dim, activation='relu')
self.dropout = tf.keras.layers.Dropout(self.hparams.hidden_dropout_rate)
self.project = tf.keras.layers.Dense(self.hparams.output_dim, activation=None)
def call(self, inputs, padding_symbol=None, training=None, **kwargs):
x = self.flat(inputs, **kwargs)
x = self.batch_norm1(x, training=training, **kwargs)
x = self.conv1(x, training=training, **kwargs)
x = self.batch_norm2(x, training=training, **kwargs)
x = self.activation(x)
x = self.dropout(x, training=training, **kwargs)
x = self.conv2(x, training=training, **kwargs)
x = self.batch_norm3(x, training=training, **kwargs)
x = self.activation(x)
x = self.dropout(x, training=training, **kwargs)
for i in range(self.hparams.num_res_net_blocks):
x = self.resblocks[i](x, training=training, **kwargs)
x = self.dropout(x, training=training, **kwargs)
x = self.conv4(x, training=training, **kwargs)
x = self.batch_norm4(x, training=training, **kwargs)
x = self.activation(x)
x = self.dropout(x, training=training, **kwargs)
x = self.dense(x, training=training, **kwargs)
x = self.dropout(x, training=training, **kwargs)
outputs = self.project(x, training=training, **kwargs)
return outputs
def detailed_call(self, inputs, padding_symbol=None, training=None, **kwargs):
self.layer_activations = []
x = self.flat(inputs, **kwargs)
x = self.batch_norm1(x, training=training, **kwargs)
x = self.conv1(x, training=training, **kwargs)
x = self.batch_norm2(x, training=training, **kwargs)
x = self.activation(x)
x = self.dropout(x, training=training, **kwargs)
self.layer_activations.append(x)
x = self.conv2(x, training=training, **kwargs)
x = self.batch_norm3(x, training=training, **kwargs)
x = self.activation(x)
x = self.dropout(x, training=training, **kwargs)
self.layer_activations.append(x)
for i in range(self.hparams.num_res_net_blocks):
x = self.resblocks[i](x, training=training, **kwargs)
x = self.dropout(x, training=training, **kwargs)
self.layer_activations.append(x)
x = self.conv4(x, training=training, **kwargs)
x = self.batch_norm4(x, training=training, **kwargs)
x = self.activation(x)
x = self.dropout(x, training=training, **kwargs)
self.layer_activations.append(x)
x = self.dense(x, training=training, **kwargs)
x = self.dropout(x, training=training, **kwargs)
self.layer_activations.append(x)
pnltimt = x
outputs = self.project(x, training=training, **kwargs)
return outputs, pnltimt, self.layer_activations | 6,118 | 39.256579 | 96 | py |
Reflect | Reflect-master/tf2_models/keras_callbacks.py | import tensorflow as tf
from tf2_models.utils import log_summary
class CheckpointCallback(tf.keras.callbacks.Callback):
def __init__(self, manager, ckpt):
super(CheckpointCallback, self).__init__()
self.manager = manager
self.ckpt = ckpt
def on_epoch_end(self, epoch, logs=None):
self.ckpt.step.assign_add(1)
save_path = self.manager.save()
tf.print("Epoch %d: " %epoch)
tf.print("Saved checkpoint for:", save_path)
class SummaryCallback(tf.keras.callbacks.Callback):
def __init__(self, summary_writer):
self.summary_writer = summary_writer
def on_train_batch_end(self, batch, logs=None):
if (self.model.optimizer.iterations % 200) == 0:
print(logs)
if 'loss' in logs.keys():
log_summary(log_name='learning_rate', log_value=self.model.optimizer.learning_rate( self.model.optimizer.iterations), summary_scope='train')
log_summary(log_name='fine_total_loss', log_value=logs['loss'], summary_scope='train')
if 'masked_sequence_loss' in logs.keys():
log_summary(log_name='fine_lm_loss', log_value=logs['masked_sequence_loss'], summary_scope='train')
if 'sequence_loss' in logs.keys():
log_summary(log_name='fine_lm_loss', log_value=logs['sequence_loss'], summary_scope='train')
def on_epoch_end(self, epoch, logs=None):
# Log summary for test and train
if 'masked_sequence_loss' in logs.keys():
log_summary(log_name='perolexity', log_value=tf.exp(logs['masked_sequence_loss']), summary_scope='train')
log_summary(log_name='perplexity', log_value=tf.exp(logs['val_masked_sequence_loss']), summary_scope='valid')
for key in logs.keys():
if 'val' in key:
log_summary(log_name=key, log_value=logs[key], summary_scope='valid')
else:
log_summary(log_name=key, log_value=logs[key], summary_scope='train')
| 1,859 | 38.574468 | 148 | py |
Reflect | Reflect-master/tf2_models/metrics.py | import tensorflow as tf
@tf.function(experimental_relax_shapes=True)
def distill_loss(y_true, y_pred, tmp):
y_true = tf.cast(tf.squeeze(y_true), dtype=tf.float32)
scale_factor = 1.0 / (tmp*tmp)
return tf.reduce_mean(tf.compat.v2.nn.softmax_cross_entropy_with_logits(logits=y_pred / tmp,
labels=y_true,
name='loss')) * scale_factor
@tf.function(experimental_relax_shapes=True)
def sequence_distill_loss(y_true, y_pred, padding_symbol, tmp):
y_true = tf.cast(tf.squeeze(y_true), dtype=tf.float32)
sequence_mask = tf.cast(y_true[..., padding_symbol] != 1.0, dtype=tf.float32)
sequence_mask = sequence_mask / tf.reduce_sum(sequence_mask)
scale_factor = 1.0 / (tmp * tmp)
return tf.reduce_sum(tf.compat.v2.nn.softmax_cross_entropy_with_logits(logits=y_pred / tmp,
labels=y_true,
name='loss') * sequence_mask) * scale_factor
@tf.function(experimental_relax_shapes=True)
def masked_sequence_loss(y_true, y_pred, padding_symbol=0):
y_true = tf.cast(tf.squeeze(y_true), dtype=tf.int64)
sequence_mask = tf.cast(y_true != padding_symbol, dtype=tf.float32)
# [batch_size, 1]
sequence_mask = sequence_mask / tf.reduce_sum(sequence_mask, axis=-1)[...,None]
return tf.reduce_mean(tf.reduce_sum(tf.compat.v2.nn.sparse_softmax_cross_entropy_with_logits(logits=y_pred,
labels=y_true,
name='loss') * sequence_mask, axis=-1))
@tf.function(experimental_relax_shapes=True)
def batch_masked_sequence_loss(y_true, y_pred, padding_symbol=0):
y_true = tf.cast(tf.squeeze(y_true), dtype=tf.int64)
sequence_mask = tf.cast(y_true != padding_symbol, dtype=tf.float32)
# [batch_size, 1]
sequence_mask = sequence_mask
return tf.compat.v2.nn.sparse_softmax_cross_entropy_with_logits(logits=y_pred,
labels=y_true,
name='loss'), sequence_mask
@tf.function(experimental_relax_shapes=True)
def masked_perplexity(y_true, y_pred, padding_symbol=0):
y_true = tf.cast(tf.squeeze(y_true), dtype=tf.int64)
sequence_mask = tf.cast(y_true != padding_symbol, dtype=tf.float32)
# [batch_size, 1]
sequence_mask = sequence_mask / tf.reduce_sum(sequence_mask, axis=-1)[...,None]
return tf.reduce_mean(tf.exp(tf.reduce_sum(tf.compat.v2.nn.sparse_softmax_cross_entropy_with_logits(logits=y_pred,
labels=y_true,
name='loss') * sequence_mask, axis=-1)))
@tf.function(experimental_relax_shapes=True)
def masked_batch_perplexity(y_true, y_pred, padding_symbol=0):
y_true = tf.cast(tf.squeeze(y_true), dtype=tf.int64)
sequence_mask = tf.cast(y_true != padding_symbol, dtype=tf.float32)
# [batch_size, 1]
sequence_mask = sequence_mask / tf.reduce_sum(sequence_mask)
return tf.exp(tf.reduce_sum(sequence_mask * tf.compat.v2.nn.sparse_softmax_cross_entropy_with_logits(logits=y_pred,
labels=y_true,
name='loss')))
#@tf.function(experimental_relax_shapes=True)
def classification_loss(y_true, y_pred):
if len(y_true.shape) > 1:
y_true = tf.squeeze(y_true, axis=-1)
y_true = tf.cast(y_true, dtype=tf.int64)
return tf.compat.v2.nn.sparse_softmax_cross_entropy_with_logits(logits=y_pred,
labels=y_true,
name='loss')
@tf.function(experimental_relax_shapes=True)
def accuracy(targets, logits, padding_symbol=0):
targets = tf.cast(tf.squeeze(targets), dtype=tf.int64)
sequence_mask = tf.cast(targets != padding_symbol, dtype=tf.float32)
return accuracy_topk(targets, logits, sequence_mask, topk=tf.constant(1))
@tf.function(experimental_relax_shapes=True)
def unmasked_accuracy(targets, logits, ):
targets = tf.cast(tf.squeeze(targets), dtype=tf.int64)
return unmasked_accuracy_topk(targets, logits, topk=tf.constant(1))
@tf.function(experimental_relax_shapes=True)
def accuracy_top2(targets, logits, padding_symbol=0):
targets = tf.cast(tf.squeeze(targets), dtype=tf.int64)
sequence_mask = tf.cast(targets != padding_symbol, dtype=tf.float32)
return accuracy_topk(targets, logits, sequence_mask, topk=tf.constant(2))
@tf.function(experimental_relax_shapes=True)
def unmasked_accuracy_top2(targets, logits, ):
targets = tf.cast(tf.squeeze(targets), dtype=tf.int64)
return unmasked_accuracy_topk(targets, logits, topk=tf.constant(2))
@tf.function(experimental_relax_shapes=True)
def accuracy_top5(targets, logits, padding_symbol=0):
targets = tf.cast(tf.squeeze(targets), dtype=tf.int64)
sequence_mask = tf.cast(targets != padding_symbol, dtype=tf.float32)
return accuracy_topk(targets, logits, sequence_mask, topk=tf.constant(5))
@tf.function(experimental_relax_shapes=True)
def unmasked_accuracy_top5(targets, logits, ):
targets = tf.cast(tf.squeeze(targets), dtype=tf.int64)
return unmasked_accuracy_topk(targets, logits, topk=tf.constant(5))
@tf.function(experimental_relax_shapes=True)
def accuracy_topk(targets, logits, sequence_mask, topk):
orig_shape = tf.shape(logits)
last_dim = orig_shape[-1]
logits = tf.reshape(logits, (-1,last_dim))
targets = tf.reshape(targets, (-1,1))
sequence_mask = tf.cast(tf.reshape(sequence_mask, (-1,1)), tf.float32)
unmasked_accuracies = tf.keras.metrics.sparse_top_k_categorical_accuracy(y_true=targets,
y_pred=logits,
k=topk)
normalizing_factor = sequence_mask / tf.reduce_sum(sequence_mask)
normalizing_factor = tf.squeeze(normalizing_factor)
return tf.reduce_sum(tf.multiply(normalizing_factor, unmasked_accuracies))
@tf.function(experimental_relax_shapes=True)
def unmasked_accuracy_topk(targets, logits, topk):
orig_shape = tf.shape(logits)
last_dim = orig_shape[-1]
logits = tf.reshape(logits, (-1,last_dim))
targets = tf.reshape(targets, (-1,1))
unmasked_accuracies = tf.keras.metrics.sparse_top_k_categorical_accuracy(y_true=targets,
y_pred=logits,
k=topk)
return tf.reduce_mean(unmasked_accuracies)
class MaskedSequenceLoss(tf.keras.losses.Loss):
def __init__(self, padding_symbol=0, num_replicas_in_sync=1,
**kwargs):
super(MaskedSequenceLoss, self).__init__(reduction=tf.keras.losses.Reduction.SUM, **kwargs)
self.padding_symbol = tf.constant(padding_symbol, dtype=tf.int64)
self.name = "batch_masked_sequence_loss"
self.num_replicas_in_sync = num_replicas_in_sync
def call(self, y_true, y_pred, sample_weight=None):
entropies, mask = batch_masked_sequence_loss(y_true=y_true, y_pred=y_pred, padding_symbol=self.padding_symbol)
if sample_weight is not None:
mask = sample_weight
norm_factor = mask / tf.reduce_sum(mask)
return tf.reduce_sum(entropies * norm_factor) / self.num_replicas_in_sync
class MaskedSequenceMetric(tf.keras.losses.Loss):
def __init__(self, padding_symbol=0,
**kwargs):
super(MaskedSequenceMetric, self).__init__(reduction=tf.keras.losses.Reduction.NONE, **kwargs)
self.padding_symbol = tf.constant(padding_symbol, dtype=tf.int64)
self.name = "batch_masked_sequence_loss"
def call(self, y_true, y_pred, sample_weight=None):
entropies, mask = batch_masked_sequence_loss(y_true=y_true, y_pred=y_pred, padding_symbol=self.padding_symbol)
if sample_weight is not None:
mask = sample_weight
norm_factor = mask / tf.reduce_sum(mask)
return tf.reduce_sum(entropies * norm_factor)
class ClassificationLoss(tf.keras.losses.Loss):
def __init__(self, global_batch_size, padding_symbol=tf.constant(0),
**kwargs):
super(ClassificationLoss, self).__init__(reduction=tf.keras.losses.Reduction.SUM, **kwargs)
self.padding_symbol = tf.constant(padding_symbol, dtype=tf.int64)
self.name = "classification_loss"
self.global_batch_size = tf.cast(global_batch_size, dtype=tf.float32)
def call(self, y_true, y_pred):
return classification_loss(y_true=y_true, y_pred=y_pred) / self.global_batch_size
class ClassificationLossMetric(tf.keras.losses.Loss):
def __init__(self, global_batch_size, padding_symbol=0,
**kwargs):
super(ClassificationLossMetric, self).__init__(reduction=tf.keras.losses.Reduction.NONE, **kwargs)
self.padding_symbol = tf.constant(padding_symbol, dtype=tf.int64)
self.name = "classification_loss"
self.global_batch_size = global_batch_size
def call(self, y_true, y_pred):
return tf.reduce_mean(classification_loss(y_true=y_true, y_pred=y_pred), axis=0)
class AccuracyTopk(tf.keras.losses.Loss):
def __init__(self, global_batch_size, padding_symbol=0, topk=1,
**kwargs):
super(AccuracyTopk, self).__init__(reduction=tf.keras.losses.Reduction.NONE, **kwargs)
self.name = '-'.join(['accuracy','top', str(topk)])
self.padding_symbol = tf.constant(padding_symbol, dtype=tf.int64)
self.global_batch_size = global_batch_size
self.topk = tf.constant(topk)
def call(self, y_true, y_pred):
y_true = tf.cast(tf.squeeze(y_true), dtype=tf.int64)
sequence_mask = tf.cast(y_true != self.padding_symbol, dtype=tf.float32)
return accuracy_topk(targets=y_true, logits=y_pred, sequence_mask=sequence_mask, topk=self.topk)
if __name__ == '__main__':
import numpy as np
a = np.asarray([[[1,1.5,2,0], [4,3,0,0]],
[[1,1.5,2,0], [4,3,0,0]]], dtype=np.float32)
a_mask = [[1, 1],[1 , 0]]
print(a_mask)
b = np.asarray([[0, 0],[1, 1]], dtype=np.int64)
print(accuracy_topk(logits=a,targets=b,sequence_mask=a_mask,topk=1)) | 10,276 | 46.578704 | 117 | py |
Reflect | Reflect-master/tf2_models/trainer.py | import tensorflow as tf
import os
from tf2_models.keras_callbacks import CheckpointCallback, SummaryCallback
from tf2_models.train_utils import RectifiedAdam, ExponentialDecayWithWarmpUp
OPTIMIZER_DIC = {'adam': tf.keras.optimizers.Adam,
'radam': RectifiedAdam,
}
class Trainer(object):
def __init__(self, hparams, strategy, model, task, train_params, log_dir, ckpt_dir):
self.hparams = hparams
self.model = model
self.task = task
self.train_params = train_params
self.strategy = strategy
lr_schedule = self.get_lr_schedule()
self.optimizer = OPTIMIZER_DIC[self.train_params.optimizer](learning_rate=lr_schedule, epsilon=1e-08, clipnorm=1.0)
self.ckpt = tf.train.Checkpoint(step=tf.Variable(1, name='checkpoint_step'), optimizer=self.optimizer, net=self.model)
self.manager = tf.train.CheckpointManager(self.ckpt, ckpt_dir,
keep_checkpoint_every_n_hours=self.hparams.keep_checkpoint_every_n_hours,
max_to_keep=2)
with self.strategy.scope():
x, y = iter(self.task.valid_dataset).next()
model(x)
model.summary()
model.compile(
optimizer=self.optimizer,
loss=self.task.get_loss_fn(),
metrics=self.task.metrics())#[self.task.get_loss_fn()])
#tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),)
summary_dir = os.path.join(log_dir, 'summaries')
tf.io.gfile.makedirs(log_dir)
self.summary_writer = tf.compat.v2.summary.create_file_writer(os.path.join(summary_dir, 'train'))
tf.compat.v2.summary.experimental.set_step(self.optimizer.iterations)
ckpt_callback = CheckpointCallback(manager=self.manager, ckpt=self.ckpt)
summary_callback = SummaryCallback(summary_writer=self.summary_writer)
self.callbacks = [ckpt_callback, summary_callback]
def get_lr_schedule(self):
if 'crs' in self.train_params.schedule:
initial_learning_rate = self.train_params.learning_rate
lr_schedule = (
tf.keras.experimental.CosineDecayRestarts(
initial_learning_rate,
self.train_params.decay_steps,
t_mul=2.0,
m_mul=0.9,
alpha=0.001,
))
elif self.train_params.optimizer == 'radam':
initial_learning_rate = self.train_params.learning_rate
lr_schedule = ExponentialDecayWithWarmpUp(
initial_learning_rate=initial_learning_rate,
decay_steps=self.train_params.decay_steps,
hold_base_rate_steps=self.train_params.hold_base_rate_steps,
decay_rate=0.96,
warmup_steps=0.0)
else:
initial_learning_rate = self.train_params.learning_rate
lr_schedule = ExponentialDecayWithWarmpUp(
initial_learning_rate=initial_learning_rate,
decay_steps=self.train_params.decay_steps,
decay_rate=0.96,
hold_base_rate_steps=self.train_params.hold_base_rate_steps,
warmup_steps=self.train_params.warmup_steps)
return lr_schedule
def restore(self):
with self.strategy.scope():
self.ckpt.restore(self.manager.latest_checkpoint)
if self.manager.latest_checkpoint:
print("Restored from {}".format(self.manager.latest_checkpoint))
else:
print("Initializing from scratch.")
def train(self):
with self.strategy.scope():
with self.summary_writer.as_default():
print("initial learning rate:", self.model.optimizer.learning_rate(self.model.optimizer.iterations))
self.model.fit(self.task.train_dataset,
epochs=self.train_params.num_train_epochs,
steps_per_epoch=self.task.n_train_batches,
validation_steps=self.task.n_valid_batches,
callbacks=self.callbacks,
validation_data=self.task.valid_dataset,
verbose=2
)
| 3,931 | 39.536082 | 122 | py |
Reflect | Reflect-master/tfds_data/tal_agreement.py | from collections import Counter
import tensorflow as tf
import tensorflow_datasets as tfds
import os
import numpy as np
from tensorflow_datasets.core.features.text import Tokenizer
from tensorflow_datasets.core.features.text.text_encoder import write_lines_to_file, read_lines_from_file
from prep_data.build_dictionary import build_and_save_dic
from util import text_util, constants
from util.text_util import deps_from_tsv, deps_to_tsv
import string
class SVAgreement(tfds.core.GeneratorBasedBuilder):
""" This is the dataset for evaluating the ability of language models to learn syntax.
Paper:
Assessing the Ability of LSTMs to Learn Syntax-Sensitive Dependencies
Tal Linzen, Emmanuel Dupoux, Yoav Goldberg
"""
VERSION = tfds.core.Version('0.1.0')
CLASS_TO_CODE = {'VBZ': 0, 'VBP': 1}
CODE_TO_CLASS = {x: y for y, x in CLASS_TO_CODE.items()}
def __init__(self, **kwargs):
super(SVAgreement, self).__init__(**kwargs)
def _info(self):
self.text_encoder_config = tfds.features.text.TextEncoderConfig(
encoder_cls=tfds.features.text.SubwordTextEncoder,
vocab_size=2 ** 13)
return tfds.core.DatasetInfo(
builder=self,
# This is the description that will appear on the datasets page.
description=("This is the dataset for subject verb agreement "
"to assess the ability of language models to learn syntax"),
# tfds.features.FeatureConnectors
features=tfds.features.FeaturesDict({
"sentence": tfds.features.Text(
encoder_config=self.text_encoder_config),
# Here, labels can be of 5 distinct values.
"verb_class": tfds.features.ClassLabel(names=["VBZ", "VBP"]),
"verb_position": tf.int32,
"n_intervening": tf.int32,
"n_diff_intervening": tf.int32,
"distance": tf.int32,
"verb": tfds.features.Text()
}),
# If there's a common (input, target) tuple from the features,
# specify them here. They'll be used if as_supervised=True in
# builder.as_dataset.
supervised_keys=("sentence", "verb_class"),
# Homepage of the dataset for documentation
urls=["https://github.com/TalLinzen/rnn_agreement"],
# Bibtex citation for the dataset
citation=r"""@article{my-awesome-dataset-2020,
author = {Linzen, Tal; Dupoux,Emmanuel; Goldberg, Yoav},"}""",
)
def _vocab_text_gen(self, input_file):
for _, ex in self._generate_examples(input_file):
yield ex["sentence"]
def _split_generators(self, dl_manager):
# Downloads the data and defines the splits
# dl_manager is a tfds.download.DownloadManager that can be used to
# download and extract URLs
extracted_path = dl_manager.download_and_extract(
'http://tallinzen.net/media/rnn_agreement/agr_50_mostcommon_10K.tsv.gz')
def make_splits(extracted_path, data_dir, prop_train=0.1, prop_valid=0.01):
# for reproducibility
np.random.seed(42)
print('| read in the data')
data = deps_from_tsv(extracted_path)
print('| shuffling')
np.random.shuffle(data)
n_train = int(len(data) * prop_train)
n_valid = int(len(data) * prop_valid)
train = data[:n_train]
valid = data[n_train: n_train + n_valid]
test = data[n_train + n_valid:]
print('| splitting')
deps_to_tsv(train, os.path.join(data_dir, "train.tsv"))
deps_to_tsv(valid, os.path.join(data_dir, "valid.tsv"))
deps_to_tsv(test, os.path.join(data_dir, "test.tsv"))
print('| done!')
make_splits(extracted_path,self.data_dir)
# Generate vocabulary from training data if SubwordTextEncoder configured
self.info.features["sentence"].maybe_build_from_corpus(
self._vocab_text_gen(os.path.join(self.data_dir, "train.tsv")))
# Specify the splits
return [
tfds.core.SplitGenerator(
name=tfds.Split.TRAIN,
gen_kwargs={
"input_file_path": os.path.join(self.data_dir, "train.tsv"),
},
),
tfds.core.SplitGenerator(
name=tfds.Split.VALIDATION,
gen_kwargs={
"input_file_path": os.path.join(self.data_dir, "valid.tsv"),
},
),
tfds.core.SplitGenerator(
name=tfds.Split.TEST,
gen_kwargs={
"input_file_path": os.path.join(self._data_dir, "test.tsv"),
},
),
]
def _generate_examples(self, input_file_path):
""" Yields examples from the dataset
:param input_file_path:
:return: example
"""
# Read the input data out of the source files
data = deps_from_tsv(input_file_path)
# And yield examples as feature dictionaries
example_id = 0
for example in data:
example_id += 1
yield example_id, {
"sentence": example['sentence'],
"verb_class": example['verb_pos'],
"verb_position": int(example['verb_index']) - 1,
"n_intervening": example['n_intervening'],
"n_diff_intervening": example['n_diff_intervening'],
"distance": example['distance'],
"verb": example['verb']
}
def sentence_encoder(self):
return self.info.features["sentence"].encoder
def vocab_size(self):
"""Retrieves the dictionary mapping word indices back to words.
Arguments:
path: where to cache the data (relative to `~/.keras/dataset`).
Returns:
The word index dictionary.
"""
return self.info.features["sentence"].encoder.vocab_size
class WordSvAgreement(SVAgreement):
""" This is the dataset for evaluating the ability of language models to learn syntax.
Paper:
Assessing the Ability of LSTMs to Learn Syntax-Sensitive Dependencies
Tal Linzen, Emmanuel Dupoux, Yoav Goldberg
"""
VERSION = tfds.core.Version('0.1.0')
CLASS_TO_CODE = {'VBZ': 0, 'VBP': 1}
CODE_TO_CLASS = {x: y for y, x in CLASS_TO_CODE.items()}
VOCAB_DIR = 'tal_agreement/vocab'
def __init__(self, data_dir, **kwargs):
self.vocab_dir = os.path.join(data_dir, self.VOCAB_DIR)
super(WordSvAgreement, self).__init__(data_dir=data_dir, **kwargs)
def _info(self):
vocab = list(np.load(self.vocab_dir, allow_pickle=True).item().keys())
print("Vocab len: ", len(vocab))
self.text_encoder_config = tfds.features.text.TextEncoderConfig(
encoder=tfds.features.text.TokenTextEncoder(vocab_list=vocab,
oov_token=constants.unk,
lowercase=False, tokenizer=tfds.features.text.Tokenizer(
alphanum_only=True,
reserved_tokens=[a for a in string.punctuation if a not in ['<', '>']] + constants.all
)))
return tfds.core.DatasetInfo(
builder=self,
# This is the description that will appear on the datasets page.
description=("This is the dataset for subject verb agreement "
"to assess the ability of language models to learn syntax"),
# tfds.features.FeatureConnectors
features=tfds.features.FeaturesDict({
"sentence": tfds.features.Text(
encoder_config=self.text_encoder_config),
# Here, labels can be of 5 distinct values.
"verb_class": tfds.features.ClassLabel(names=["VBZ", "VBP"]),
"verb_position": tf.int32,
"n_intervening": tf.int32,
"n_diff_intervening": tf.int32,
"distance": tf.int32,
"verb": tfds.features.Text()
}),
# If there's a common (input, target) tuple from the features,
# specify them here. They'll be used if as_supervised=True in
# builder.as_dataset.
supervised_keys=("sentence", "verb_class"),
# Homepage of the dataset for documentation
homepage="https://github.com/TalLinzen/rnn_agreement",
# Bibtex citation for the dataset
citation=r"""@article{my-awesome-dataset-2020,
author = {Linzen, Tal; Dupoux,Emmanuel; Goldberg, Yoav},"}""",
)
if __name__ == '__main__':
databuilder = WordSvAgreement(data_dir='data')
databuilder.download_and_prepare(download_dir='tmp/',
download_config=tfds.download.DownloadConfig(register_checksums=True))
dataset = databuilder.as_dataset(split="validation", batch_size=1000)
dataset = tfds.as_numpy(dataset)
for batch in dataset:
print("encoded_sentence:", batch['sentence'])
print("decoded_sentence:", databuilder.sentence_encoder().decode(batch['sentence'][0]))
print("verb class:", batch['verb_class'][0])
print("verb position:",batch['verb_position'][0])
print("distance:",batch['distance'][0])
break
print(databuilder.vocab_size())
| 8,680 | 35.020747 | 106 | py |
Reflect | Reflect-master/tasks/sv_agreement.py | import functools
from distill.distill_util import DistillLoss, get_probs, SequenceDistillLoss, get_topk_masked_probs, get_masked_probs
from tasks.task import Task
import tensorflow as tf
from tf2_models import metrics
from tf2_models.metrics import masked_batch_perplexity, masked_perplexity, \
MaskedSequenceLoss, ClassificationLoss
from tfds_data.tal_agreement import WordSvAgreement, SVAgreement
from util import constants
class SvAgreementLM(Task):
def __init__(self, task_params, name='sv_agreement_lm', data_dir='data', builder_cls=SVAgreement):
super(SvAgreementLM, self).__init__(task_params=task_params, name=name, data_dir=data_dir, builder_cls=builder_cls,
output_padding=True)
@tf.function
def convert_examples(self, examples):
sentences = examples['sentence']
s_shape = tf.shape(sentences)
#batch_size, length = s_shape[0], s_shape[1]
bos = self.databuilder.sentence_encoder().encode(constants.bos)
eos = self.databuilder.sentence_encoder().encode(constants.eos)
sentence = tf.concat([bos, sentences, eos], axis=-1)
return sentence[:-1],\
sentence[1:]
def get_loss_fn(self):
return MaskedSequenceLoss(padding_symbol=tf.constant(self.output_padding_symbol, dtype=tf.int64), num_replicas_in_sync=self.task_params.num_replicas_in_sync)
def vocab_size(self):
return self.databuilder.vocab_size()
def output_size(self):
return self.vocab_size()
def sentence_encoder(self):
return self.databuilder.sentence_encoder()
def get_distill_loss_fn(self, distill_params):
return SequenceDistillLoss(tmp=distill_params.distill_temp, padding_symbol=tf.constant(self.output_padding_symbol, dtype=tf.int64))
def get_probs_fn(self):
return get_masked_probs
def metrics(self):
return [MaskedSequenceLoss(padding_symbol=tf.constant(self.output_padding_symbol, dtype=tf.int64)),
functools.update_wrapper(functools.partial(masked_batch_perplexity,
padding_symbol=tf.constant(self.output_padding_symbol,
dtype=tf.int64)),
masked_batch_perplexity),
functools.update_wrapper(functools.partial(masked_perplexity,
padding_symbol=tf.constant(self.output_padding_symbol,
dtype=tf.int64)),
masked_perplexity),
metrics.AccuracyTopk(global_batch_size=self.task_params.batch_size, padding_symbol=tf.constant(self.output_padding_symbol, dtype=tf.int64), topk=1),
metrics.AccuracyTopk(global_batch_size=self.task_params.batch_size, padding_symbol=tf.constant(self.output_padding_symbol, dtype=tf.int64), topk=2),
metrics.AccuracyTopk(global_batch_size=self.task_params.batch_size, padding_symbol=tf.constant(self.output_padding_symbol, dtype=tf.int64), topk=5)
]
class WordSvAgreementLM(SvAgreementLM):
def __init__(self, task_params, name='word_sv_agreement_lm', data_dir='data', builder_cls=WordSvAgreement):
super(WordSvAgreementLM, self).__init__(task_params=task_params, name=name, data_dir=data_dir, builder_cls=builder_cls)
class WordSvAgreementVP(Task):
def __init__(self, task_params, name='word_sv_agreement_vp', data_dir='data', builder_cls=WordSvAgreement):
super(WordSvAgreementVP, self).__init__(task_params=task_params, name=name, data_dir=data_dir,
builder_cls=builder_cls,
output_padding=False)
@property
def padded_shapes(self):
return ([None],[])
@tf.function
def convert_examples(self, examples):
sentences = examples['sentence']
#bos = self.databuilder.sentence_encoder().encode(constants.bos)
eos = self.databuilder.sentence_encoder().encode(constants.eos)
sentences = tf.concat([sentences, eos], axis=-1)
verb_position = examples['verb_position']
# The verb it self is also masked
mask = tf.cast(tf.sequence_mask(verb_position,maxlen=tf.shape(sentences)[0]), dtype=tf.int64)
max_length = tf.reduce_max(verb_position + 1)
last_index_mask = tf.eye(tf.shape(sentences)[0], dtype=tf.int64)[verb_position]
last_index_mask = last_index_mask * eos[0]
return (sentences * mask + last_index_mask)[:max_length], \
examples['verb_class']
def vocab_size(self):
return self.databuilder.vocab_size()
def output_size(self):
return 2
def get_loss_fn(self):
return ClassificationLoss(global_batch_size=tf.constant(self.task_params.batch_size), padding_symbol=tf.constant(self.output_padding_symbol, dtype=tf.int64))
def get_distill_loss_fn(self, distill_params):
return DistillLoss(tmp=tf.constant(distill_params.distill_temp), padding_symbol=tf.constant(self.output_padding_symbol, dtype=tf.int64))
def get_probs_fn(self):
return get_probs
def metrics(self):
return [ClassificationLoss(global_batch_size=tf.constant(self.task_params.batch_size), padding_symbol=tf.constant(self.output_padding_symbol, dtype=tf.int64)),
tf.keras.metrics.SparseCategoricalAccuracy()]
def sentence_encoder(self):
return self.databuilder.sentence_encoder() | 5,424 | 44.208333 | 163 | py |
Reflect | Reflect-master/tasks/mnist.py | from distill.distill_util import DistillLoss, get_probs
from tasks.task import Task
import tensorflow as tf
import tensorflow_datasets as tfds
from tf2_models.metrics import ClassificationLoss
from tfds_data.aff_nist import AffNist
class Mnist(Task):
def __init__(self, task_params, name='mnist', data_dir='mnist_data'):
self.databuilder = tfds.builder("mnist")
super(Mnist, self).__init__(task_params=task_params, name=name,
data_dir=data_dir,
builder_cls=None)
def vocab_size(self):
return 28*28
def output_size(self):
return 10
def get_loss_fn(self):
return ClassificationLoss(global_batch_size=self.task_params.batch_size,
padding_symbol=tf.constant(-1, dtype=tf.int64))
def get_distill_loss_fn(self, distill_params):
return DistillLoss(tmp=distill_params.distill_temp)
def get_probs_fn(self):
return get_probs
def metrics(self):
return [ClassificationLoss(global_batch_size=self.task_params.batch_size,
padding_symbol=tf.constant(-1, dtype=tf.int64)),
tf.keras.metrics.SparseCategoricalAccuracy()]
@property
def padded_shapes(self):
# To make sure we are not using this!
raise NotImplementedError
def convert_examples(self, examples):
return tf.cast(examples['image'], dtype=tf.float32)/255, tf.cast(examples['label'], dtype=tf.int32)
def setup_datasets(self):
self.info = self.databuilder.info
self.n_train_batches = int(
self.info.splits['train'].num_examples / self.task_params.batch_size)
self.n_test_batches = int(
self.info.splits['test'].num_examples / self.task_params.batch_size)
self.n_valid_batches = int(
self.info.splits['test'].num_examples / self.task_params.batch_size)
self.databuilder.download_and_prepare(download_dir=self.data_dir)
self.test_dataset = self.databuilder.as_dataset(split="test")
assert isinstance(self.test_dataset, tf.data.Dataset)
self.test_dataset = self.test_dataset.map(map_func=lambda x: self.convert_examples(x),
num_parallel_calls=tf.data.experimental.AUTOTUNE)
self.test_dataset = self.test_dataset.repeat()
self.test_dataset = self.test_dataset.batch(
batch_size=self.task_params.batch_size)
self.test_dataset = self.test_dataset.prefetch(
tf.data.experimental.AUTOTUNE)
self.train_dataset = self.databuilder.as_dataset(split="train")
assert isinstance(self.train_dataset, tf.data.Dataset)
self.train_dataset = self.train_dataset.map(map_func=lambda x: self.convert_examples(x),
num_parallel_calls=tf.data.experimental.AUTOTUNE)
self.train_dataset = self.train_dataset.repeat()
self.train_dataset = self.train_dataset.shuffle(1024)
self.train_dataset = self.train_dataset.batch(
batch_size=self.task_params.batch_size)
# self.train_dataset = self.train_dataset.cache()
self.train_dataset = self.train_dataset.prefetch(
tf.data.experimental.AUTOTUNE)
self.valid_dataset = self.databuilder.as_dataset(split="test")
assert isinstance(self.valid_dataset, tf.data.Dataset)
self.valid_dataset = self.valid_dataset.map(map_func=lambda x: self.convert_examples(x),
num_parallel_calls=tf.data.experimental.AUTOTUNE)
self.valid_dataset = self.valid_dataset.repeat()
self.valid_dataset = self.valid_dataset.batch(
batch_size=self.task_params.batch_size)
self.valid_dataset = self.valid_dataset.prefetch(
tf.data.experimental.AUTOTUNE)
class AffNistTask(Task):
def __init__(self, task_params, name='aff_nist',data_dir='data', builder_cls=AffNist):
super(AffNistTask, self).__init__(task_params=task_params, name=name,
data_dir=data_dir,
builder_cls=builder_cls)
def input_shape(self):
"""
To be used when calling model.build(input_shape)
:return:
#[batch_size, height, width, channels
"""
return [None, 32, 32, 1]
def vocab_size(self):
return 40*40
def output_size(self):
return 10
def get_loss_fn(self):
return ClassificationLoss(global_batch_size=self.task_params.batch_size,
padding_symbol=tf.constant(-1, dtype=tf.int64))
def get_distill_loss_fn(self, distill_params):
return DistillLoss(tmp=distill_params.distill_temp)
def get_probs_fn(self):
return get_probs
def metrics(self):
return [ClassificationLoss(global_batch_size=self.task_params.batch_size,
padding_symbol=tf.constant(-1, dtype=tf.int64)),
tf.keras.metrics.SparseCategoricalAccuracy()]
@property
def padded_shapes(self):
# To make sure we are not using this!
raise NotImplementedError
def convert_examples(self, examples):
return tf.cast(examples['image'], dtype=tf.float32)/255, tf.cast(examples['label'], dtype=tf.int32)
def setup_datasets(self):
self.info = self.databuilder.info
self.n_train_batches = int(
self.info.splits['train'].num_examples / self.task_params.batch_size)
self.n_test_batches = int(
self.info.splits['test'].num_examples / self.task_params.batch_size)
self.n_valid_batches = int(
self.info.splits['test'].num_examples / self.task_params.batch_size)
self.test_dataset = self.databuilder.as_dataset(split="test")
assert isinstance(self.test_dataset, tf.data.Dataset)
self.test_dataset = self.test_dataset.map(map_func=lambda x: self.convert_examples(x),
num_parallel_calls=tf.data.experimental.AUTOTUNE)
self.test_dataset = self.test_dataset.repeat()
self.test_dataset = self.test_dataset.batch(
batch_size=self.task_params.batch_size)
self.test_dataset = self.test_dataset.prefetch(
tf.data.experimental.AUTOTUNE)
self.train_dataset = self.databuilder.as_dataset(split="train")
assert isinstance(self.train_dataset, tf.data.Dataset)
self.train_dataset = self.train_dataset.map(map_func=lambda x: self.convert_examples(x),
num_parallel_calls=tf.data.experimental.AUTOTUNE)
self.train_dataset = self.train_dataset.repeat()
self.train_dataset = self.train_dataset.shuffle(1024)
self.train_dataset = self.train_dataset.batch(
batch_size=self.task_params.batch_size)
# self.train_dataset = self.train_dataset.cache()
self.train_dataset = self.train_dataset.prefetch(
tf.data.experimental.AUTOTUNE)
self.valid_dataset = self.databuilder.as_dataset(split="test")
assert isinstance(self.valid_dataset, tf.data.Dataset)
self.valid_dataset = self.valid_dataset.map(map_func=lambda x: self.convert_examples(x),
num_parallel_calls=tf.data.experimental.AUTOTUNE)
self.valid_dataset = self.valid_dataset.repeat()
self.valid_dataset = self.valid_dataset.batch(
batch_size=self.task_params.batch_size)
self.valid_dataset = self.valid_dataset.prefetch(
tf.data.experimental.AUTOTUNE)
class Svhn(Mnist):
def __init__(self, task_params, name='svhn', data_dir='mnist_data'):
self.databuilder = tfds.builder("svhn_cropped")
super(Mnist, self).__init__(task_params=task_params, name=name,
data_dir=data_dir,
builder_cls=None)
def vocab_size(self):
return 32 * 32
def input_shape(self):
"""
To be used when calling model.build(input_shape)
:return:
#[batch_size, height, width, channels
"""
return [None, 32, 32, 1]
class Mnist40(Mnist):
def __init__(self, task_params, name='mnist40', data_dir='mnist_data'):
self.databuilder = tfds.builder("mnist")
super(Mnist, self).__init__(task_params=task_params, name=name,
data_dir=data_dir,
builder_cls=None)
def vocab_size(self):
return 40 * 40
def output_size(self):
return 10
def input_shape(self):
"""
To be used when calling model.build(input_shape)
:return:
#[batch_size, height, width, channels
"""
return [None, 32, 32, 1]
def convert_examples(self, examples):
pad_length = int((40 - 28) / 2)
return tf.pad(tf.cast(examples['image'], dtype=tf.float32) / 255,
([pad_length, pad_length], [pad_length, pad_length],
[0, 0])), tf.cast(
examples['label'], dtype=tf.int32)
| 8,663 | 37.678571 | 103 | py |
PyKrige | PyKrige-main/docs/source/conf.py | #!/usr/bin/env python3
# -*- coding: utf-8 -*-
#
# PyKrige documentation build configuration file, created by
# sphinx-quickstart on Wed Mar 1 18:34:53 2017.
#
# This file is execfile()d with the current directory set to its
# containing dir.
#
# Note that not all possible configuration values are present in this
# autogenerated file.
#
# All configuration values have a default; values that are commented out
# serve to show the default.
import datetime
import os
import shlex
import sys
import matplotlib
import sphinx_rtd_theme
matplotlib.use("Agg")
# If extensions (or modules to document with autodoc) are in another directory,
# add these directories to sys.path here. If the directory is relative to the
# documentation root, use os.path.abspath to make it absolute, like shown here.
# sys.path.insert(0, os.path.abspath("../../"))
sys.path.insert(0, os.path.abspath("sphinxext"))
from github_link import make_linkcode_resolve
import pykrige
# -- General configuration ------------------------------------------------
# If your documentation needs a minimal Sphinx version, state it here.
# needs_sphinx = '1.0'
# Add any Sphinx extension module names here, as strings. They can be
# extensions coming with Sphinx (named 'sphinx.ext.*') or your custom
# ones.
extensions = [
"sphinx.ext.autodoc",
"sphinx.ext.doctest",
"sphinx.ext.mathjax",
"sphinx.ext.autodoc",
"sphinx.ext.autosummary",
"sphinx.ext.napoleon", # parameters look better than with numpydoc only
"numpydoc",
"sphinx_gallery.gen_gallery",
"sphinx.ext.linkcode",
"m2r2",
]
autodoc_default_flags = ["members", "inherited-members"]
# autosummaries from source-files
autosummary_generate = True
# dont show __init__ docstring
autoclass_content = "class"
# sort class members
autodoc_member_order = "groupwise"
# autodoc_member_order = 'bysource'
# Notes in boxes
napoleon_use_admonition_for_notes = True
# Attributes like parameters
# napoleon_use_ivar = True
# this is a nice class-doc layout
numpydoc_show_class_members = True
# class members have no separate file, so they are not in a toctree
numpydoc_class_members_toctree = False
# for the covmodels alot of classmembers show up...
# maybe switch off with: :no-inherited-members:
numpydoc_show_inherited_class_members = True
# Add any paths that contain templates here, relative to this directory.
templates_path = ["_templates"]
# The suffix(es) of source filenames.
# You can specify multiple suffix as a list of string:
source_suffix = {
".rst": "restructuredtext",
".txt": "restructuredtext",
".md": "markdown",
}
# The encoding of source files.
# source_encoding = 'utf-8-sig'
# The master toctree document.
master_doc = "contents"
sphinx_gallery_conf = {
# path to your examples scripts
"examples_dirs": "../../examples",
# path where to save gallery generated examples
"gallery_dirs": "examples",
"filename_pattern": "/.*.py",
}
# General information about the project.
curr_year = datetime.datetime.now().year
project = "PyKrige"
copyright = "2017 - {}, PyKrige developers".format(curr_year)
author = "PyKrige developers"
# The version info for the project you're documenting, acts as replacement for
# |version| and |release|, also used in various other places throughout the
# built documents.
#
# The short X.Y version.
version = pykrige.__version__
# The full version, including alpha/beta/rc tags.
release = pykrige.__version__
# The language for content autogenerated by Sphinx. Refer to documentation
# for a list of supported languages.
#
# This is also used if you do content translation via gettext catalogs.
# Usually you set "language" from the command line for these cases.
language = None
# There are two options for replacing |today|: either, you set today to some
# non-false value, then it is used:
# today = ''
# Else, today_fmt is used as the format for a strftime call.
# today_fmt = '%B %d, %Y'
# List of patterns, relative to source directory, that match files and
# directories to ignore when looking for source files.
exclude_patterns = ["_build"]
# The reST default role (used for this markup: `text`) to use for all
# documents.
# default_role = None
# If true, '()' will be appended to :func: etc. cross-reference text.
# add_function_parentheses = True
# If true, the current module name will be prepended to all description
# unit titles (such as .. function::).
# add_module_names = True
# If true, sectionauthor and moduleauthor directives will be shown in the
# output. They are ignored by default.
# show_authors = False
# The name of the Pygments (syntax highlighting) style to use.
pygments_style = "sphinx"
# A list of ignored prefixes for module index sorting.
# modindex_common_prefix = []
# If true, keep warnings as "system message" paragraphs in the built documents.
# keep_warnings = False
# If true, `todo` and `todoList` produce output, else they produce nothing.
todo_include_todos = False
# -- Options for HTML output ----------------------------------------------
# The theme to use for HTML and HTML Help pages. See the documentation for
# a list of builtin themes.
html_theme = "sphinx_rtd_theme"
# Theme options are theme-specific and customize the look and feel of a theme
# further. For a list of options available for each theme, see the
# documentation.
# html_theme_options = {}
# Add any paths that contain custom themes here, relative to this directory.
# html_theme_path = []
# The name for this set of Sphinx documents. If None, it defaults to
# "<project> v<release> documentation".
# html_title = None
# A shorter title for the navigation bar. Default is the same as html_title.
# html_short_title = None
# The name of an image file (relative to this directory) to place at the top
# of the sidebar.
# html_logo = None
# The name of an image file (within the static path) to use as favicon of the
# docs. This file should be a Windows icon file (.ico) being 16x16 or 32x32
# pixels large.
# html_favicon = None
# Add any paths that contain custom static files (such as style sheets) here,
# relative to this directory. They are copied after the builtin static files,
# so a file named "default.css" will overwrite the builtin "default.css".
# html_static_path = ["_static"]
# Add any extra paths that contain custom files (such as robots.txt or
# .htaccess) here, relative to this directory. These files are copied
# directly to the root of the documentation.
# html_extra_path = []
# If not '', a 'Last updated on:' timestamp is inserted at every page bottom,
# using the given strftime format.
# html_last_updated_fmt = '%b %d, %Y'
# If true, SmartyPants will be used to convert quotes and dashes to
# typographically correct entities.
# html_use_smartypants = True
# Custom sidebar templates, maps document names to template names.
# html_sidebars = {}
# Additional templates that should be rendered to pages, maps page names to
# template names.
# html_additional_pages = {}
# If false, no module index is generated.
# html_domain_indices = True
# If false, no index is generated.
# html_use_index = True
# If true, the index is split into individual pages for each letter.
# html_split_index = False
# If true, links to the reST sources are added to the pages.
html_show_sourcelink = True
# If true, "Created using Sphinx" is shown in the HTML footer. Default is True.
# html_show_sphinx = True
# If true, "(C) Copyright ..." is shown in the HTML footer. Default is True.
# html_show_copyright = True
# If true, an OpenSearch description file will be output, and all pages will
# contain a <link> tag referring to it. The value of this option must be the
# base URL from which the finished HTML is served.
# html_use_opensearch = ''
# This is the file name suffix for HTML files (e.g. ".xhtml").
# html_file_suffix = None
# Language to be used for generating the HTML full-text search index.
# Sphinx supports the following languages:
# 'da', 'de', 'en', 'es', 'fi', 'fr', 'h', 'it', 'ja'
# 'nl', 'no', 'pt', 'ro', 'r', 'sv', 'tr'
# html_search_language = 'en'
# A dictionary with options for the search language support, empty by default.
# Now only 'ja' uses this config value
# html_search_options = {'type': 'default'}
# The name of a javascript file (relative to the configuration directory) that
# implements a search results scorer. If empty, the default will be used.
# html_search_scorer = 'scorer.js'
# Output file base name for HTML help builder.
htmlhelp_basename = "PyKrigedoc"
html_logo = "pics/PyKrige_150.png"
html_favicon = "pics/PyKrige.ico"
# -- Options for LaTeX output ---------------------------------------------
latex_logo = "pics/PyKrige_150.png"
latex_elements = {
# The paper size ('letterpaper' or 'a4paper').
#'papersize': 'letterpaper',
# The font size ('10pt', '11pt' or '12pt').
#'pointsize': '10pt',
# Additional stuff for the LaTeX preamble.
#'preamble': '',
# Latex figure (float) alignment
#'figure_align': 'htbp',
}
# Grouping the document tree into LaTeX files. List of tuples
# (source start file, target name, title,
# author, documentclass [howto, manual, or own class]).
latex_documents = [
(master_doc, "PyKrige.tex", "PyKrige Documentation", "PyKrige developers", "manual")
]
# The name of an image file (relative to this directory) to place at the top of
# the title page.
# latex_logo = None
# For "manual" documents, if this is true, then toplevel headings are parts,
# not chapters.
# latex_use_parts = False
# If true, show page references after internal links.
# latex_show_pagerefs = False
# If true, show URL addresses after external links.
# latex_show_urls = False
# Documents to append as an appendix to all manuals.
# latex_appendices = []
# If false, no module index is generated.
# latex_domain_indices = True
# -- Options for manual page output ---------------------------------------
# One entry per manual page. List of tuples
# (source start file, name, description, authors, manual section).
man_pages = [(master_doc, "pykrige", "PyKrige Documentation", [author], 1)]
# If true, show URL addresses after external links.
# man_show_urls = False
# -- Options for Texinfo output -------------------------------------------
# Grouping the document tree into Texinfo files. List of tuples
# (source start file, target name, title, author,
# dir menu entry, description, category)
texinfo_documents = [
(
master_doc,
"PyKrige",
"PyKrige Documentation",
author,
"PyKrige",
"One line description of project.",
"Miscellaneous",
)
]
# Documents to append as an appendix to all manuals.
# texinfo_appendices = []
# If false, no module index is generated.
# texinfo_domain_indices = True
# How to display URL addresses: 'footnote', 'no', or 'inline'.
# texinfo_show_urls = 'footnote'
# If true, do not generate a @detailmenu in the "Top" node's menu.
# texinfo_no_detailmenu = False
# The following is used by sphinx.ext.linkcode to provide links to github
linkcode_resolve = make_linkcode_resolve(
"pykrige",
"https://github.com/GeoStat-Framework/"
"PyKrige/blob/{revision}/"
"{package}/{path}#L{lineno}",
)
| 11,242 | 30.940341 | 88 | py |
A-Quantile-based-Approach-for-Hyperparameter-Transfer-Learning | A-Quantile-based-Approach-for-Hyperparameter-Transfer-Learning-master/src/misc/__init__.py | import random
import numpy as np
import torch
def set_seed(seed: int):
torch.manual_seed(seed)
np.random.seed(seed)
random.seed(seed)
| 149 | 12.636364 | 27 | py |
A-Quantile-based-Approach-for-Hyperparameter-Transfer-Learning | A-Quantile-based-Approach-for-Hyperparameter-Transfer-Learning-master/src/prior/mlp_pytorch.py | import tempfile
import uuid
from pathlib import Path
from typing import Optional, Tuple
from sklearn.preprocessing import StandardScaler
from constants import num_gradient_updates
import numpy as np
from tqdm import tqdm
import torch
from torch import nn
from torch.utils.data import Dataset, DataLoader, TensorDataset
from prior import Prior
def train(
module,
X_train: np.array,
y_train: np.array,
num_gradient_updates: int = num_gradient_updates,
lr: float = 1e-2,
num_decays: int = 3,
factor_decay: float = 5.0,
batch_size: int = 64,
clip_gradient: Optional[float] = None,
optimizer=None,
early_stopping: bool = True,
):
dataset = TensorDataset(
torch.Tensor(X_train),
torch.Tensor(y_train)
)
# keep 10% of train dataset as validation
num_train = len(dataset) * 9 // 10
train_dataset, val_dataset = torch.utils.data.random_split(dataset, [num_train, len(dataset) - num_train])
# dont use gpu for now
# device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
# module = module.to(device)
def infinite_stream():
while True:
# reshuffle
dataloader = DataLoader(train_dataset, batch_size=batch_size, shuffle=True)
for data in dataloader:
yield data
train_losses = []
val_rmses = []
first = True
if optimizer is None:
optimizer = torch.optim.Adam(module.parameters(), lr=lr)
checkpoint_freq = 100
it = 0
best_val_rmse = float("inf")
checkpoint_path = Path(tempfile.gettempdir()) / f"best-model-{uuid.uuid4().hex}.pth"
with torch.autograd.set_detect_anomaly(True):
for _ in range(num_decays):
with tqdm(infinite_stream(), total=num_gradient_updates, miniters=200, mininterval=2) as tqdm_iter:
for X_batch, y_batch in tqdm_iter:
optimizer.zero_grad()
# both of shape (batch_size, output_dim,) we could also fit a covariate matrix to account
# the dependency between different criterion
mu, sigma = module(X_batch)
distr = torch.distributions.normal.Normal(loc=mu, scale=sigma)
# y_batch has shape (batch_size, output_dim)
loss = - distr.log_prob(y_batch).mean()
loss.backward()
loss_value = loss.item()
if clip_gradient is not None:
nn.utils.clip_grad_norm_(
module.parameters(),
max_norm=clip_gradient
)
if first:
def count_parameters(model):
return sum(p.numel() for p in model.parameters() if p.requires_grad)
print(
"\n".join(f"{name}: shape {p.shape}, {p.numel()} parameters" for name, p in
module.named_parameters() if p.requires_grad)
)
print(f"number of parameters: {count_parameters(module)}")
first = False
# print(loss_value)
train_losses.append(loss_value)
optimizer.step()
metrics_dict = {
"train_loss": loss_value,
}
if it % checkpoint_freq == 0:
for X_val, y_val in DataLoader(val_dataset, batch_size=len(val_dataset)):
# compute mean
mu, sigma = module(X_val)
val_rmse = ((mu - y_val) ** 2).mean().sqrt().item()
metrics_dict['val_rmse'] = val_rmse
val_rmses.append(val_rmse)
if early_stopping and val_rmse < best_val_rmse:
# print(f" found better loss {val_rmse} than {best_val_rmse}, checkpointing in {checkpoint_path}")
best_val_rmse = min(best_val_rmse, val_rmse)
torch.save(module.state_dict(), checkpoint_path)
tqdm_iter.set_postfix(metrics_dict)
it += 1
if it % num_gradient_updates == 0:
break
lr /= factor_decay
if early_stopping:
print(f"loading best model found at {checkpoint_path} with val_rmse={val_rmse}")
module.load_state_dict(torch.load(checkpoint_path))
return module, (train_losses, val_rmses)
class GaussianRegression(nn.Module):
def __init__(self, input_dim: int, num_layers: int = 3, num_hidden: int = 40, dropout: float = 0.0):
super(GaussianRegression, self).__init__()
layers = [nn.Linear(input_dim, num_hidden)]
for i in range(num_layers):
layers.append(nn.Linear(num_hidden, num_hidden))
layers.append(nn.ReLU())
layers.append(nn.Dropout(dropout))
self.layers = nn.Sequential(*layers)
self.mu_proj = nn.Linear(num_hidden, 1)
self.sigma_proj = nn.Sequential(nn.Linear(num_hidden, 1), nn.Softplus())
def init(m):
if type(m) == nn.Linear:
nn.init.xavier_uniform_(m.weight)
# use the modules apply function to recursively apply the initialization
self.layers.apply(init)
def forward(self, x):
x_hidden = self.layers(x)
mu = self.mu_proj(x_hidden)
sigma = self.sigma_proj(x_hidden)
return mu, sigma
class ParametricPrior(Prior):
def __init__(
self,
X_train: np.array,
y_train: np.array,
num_gradient_updates: int = num_gradient_updates,
dropout: float = 0.1,
num_layers: int = 3,
num_hidden: int = 50,
**train_kwargs
):
super(ParametricPrior, self).__init__(
X_train=X_train,
y_train=y_train,
)
n, dim = X_train.shape
self.scaler = StandardScaler()
module = GaussianRegression(input_dim=dim, num_layers=num_layers, num_hidden=num_hidden, dropout=dropout)
self.module, _ = train(
module=module,
X_train=self.scaler.fit_transform(X_train),
y_train=y_train,
num_gradient_updates=num_gradient_updates,
**train_kwargs
)
def predict(self, X: np.array) -> Tuple[np.array, np.array]:
X_test = torch.Tensor(self.scaler.transform(X))
self.module.eval()
mu, sigma = self.module(X_test)
return mu.detach().numpy(), sigma.detach().numpy()
| 6,805 | 36.191257 | 126 | py |