python_code
stringlengths 0
992k
| repo_name
stringlengths 8
46
| file_path
stringlengths 5
162
|
|---|---|---|
from dynamic_fusion_graph.model import DynamicFusionGraph as DynamicFusionGraph
from recurrent_fusion.model import RecurrentFusion as RecurrentFusion
from tensor_fusion.model import TensorFusion as TensorFusion
from multiple_attention.model import MultipleAttentionFusion as MultipleAttentionFusion
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmmodelsdk/fusion/__init__.py |
EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmmodelsdk/fusion/multiple_attention/__init__.py |
|
#CMU Multimodal SDK, CMU Multimodal Model SDK
#Multi-attention Recurrent Network for Human Communication Comprehension, Amir Zadeh, Paul Pu Liang, Soujanya Poria, Erik Cambria, Prateek Vij, Louis-Philippe Morency - https://arxiv.org/pdf/1802.00923.pdf
#in_modalities: is a list of inputs from each modality - the first dimension of all the modality inputs must be the same, it will be the batch size. The second dimension is the feature dimension. There are a total of n modalities.
#attention_model: is a pytorch nn.Sequential which takes in an input with size (bs * m0+...+mn) with m_i being the dimensionality of the features in modality i. Output is the (bs * (m0+...+mn)*num_atts).
#dim_reduce_nets: is a list of pytorch nn.Sequential which takes in an input with size (bs*(mi*num_atts))
#num_atts is the number of attentions
#num_atts: number of attentions
import torch
import time
from torch import nn
import torch.nn.functional as F
class MultipleAttentionFusion(nn.Module):
def __init__(self,attention_model,dim_reduce_nets,num_atts):
super(MultipleAttentionFusion, self).__init__()
self.attention_model=attention_model
self.dim_reduce_nets=dim_reduce_nets
self.num_atts=num_atts
def __call__(self,in_modalities):
return self.fusion(in_modalities)
def fusion(self,in_modalities):
#getting some simple integers out
num_modalities=len(in_modalities)
#simply the tensor that goes into attention_model
in_tensor=torch.cat(in_modalities,dim=1)
#calculating attentions
atts=F.softmax(self.attention_model(in_tensor),dim=1)
#calculating the tensor that will be multiplied with the attention
out_tensor=torch.cat([in_modalities[i].repeat(1,self.num_atts) for i in range(num_modalities)],dim=1)
#calculating the attention
att_out=atts*out_tensor
#now to apply the dim_reduce networks
#first back to however modalities were in the problem
start=0
out_modalities=[]
for i in range(num_modalities):
modality_length=in_modalities[i].shape[1]*self.num_atts
out_modalities.append(att_out[:,start:start+modality_length])
start=start+modality_length
#apply the dim_reduce
dim_reduced=[self.dim_reduce_nets[i](out_modalities[i]) for i in range(num_modalities)]
#multiple attention done :)
return dim_reduced,out_modalities
def forward(self, x):
print("Not yet implemented for nn.Sequential")
exit(-1)
if __name__=="__main__":
print("This is a module and hence cannot be called directly ...")
print("A toy sample will now run ...")
from torch.autograd import Variable
import torch.nn.functional as F
import numpy
inputx=Variable(torch.Tensor(numpy.array(numpy.zeros([32,40]))),requires_grad=True)
inputy=Variable(torch.Tensor(numpy.array(numpy.zeros([32,12]))),requires_grad=True)
inputz=Variable(torch.Tensor(numpy.array(numpy.zeros([32,20]))),requires_grad=True)
modalities=[inputx,inputy,inputz]
#simple functions for toy example, 4 times extract attentions hence 72*4
my_attention = nn.Sequential(nn.Linear(72,72*4))
small_netx = nn.Sequential(nn.Linear(160,10))
small_nety = nn.Sequential(nn.Linear(48,20))
small_netz = nn.Sequential(nn.Linear(80,30))
smalls_nets=[small_netx,small_nety,small_netz]
fmodel=MultipleAttentionFusion(my_attention,smalls_nets,4)
out=fmodel(modalities)
print("Output")
print(out[0])
print("Toy sample finished ...")
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmmodelsdk/fusion/multiple_attention/model.py |
EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmmodelsdk/fusion/recurrent_fusion/__init__.py |
|
#CMU Multimodal SDK, CMU Multimodal Model SDK
#Multimodal Language Analysis with Recurrent Multistage Fusion, Paul Pu Liang, Ziyin Liu, Amir Zadeh, Louis-Philippe Morency - https://arxiv.org/abs/1808.03920
#in_dimensions: the list of dimensionalities of each modality
#cell_size: lstm cell size
#in_modalities: is a list of inputs from each modality - the first dimension of all the modality inputs must be the same, it will be the batch size. The second dimension is the feature dimension. There are a total of n modalities.
#steps: number of iterations for the recurrent fusion
import torch
import time
from torch import nn
import torch.nn.functional as F
from six.moves import reduce
class RecurrentFusion(nn.Module):
def __init__(self,in_dimensions,cell_size):
super(RecurrentFusion, self).__init__()
self.in_dimensions=in_dimensions
self.cell_size=cell_size
self.model=nn.LSTM(sum(in_dimensions),cell_size)
def __call__(self,in_modalities,steps=1):
return self.fusion(in_modalities,steps)
def fusion(self,in_modalities,steps=1):
bs=in_modalities[0].shape[0]
model_input=torch.cat(in_modalities,dim=1).view(1,bs,-1).repeat([steps,1,1])
hidden,cell = (torch.zeros(1, bs, self.cell_size),torch.zeros(1, bs, self.cell_size))
for i in range(steps):
outputs,last_states=self.model(model_input,[hidden,cell])
return outputs,last_states[0],last_states[1]
def forward(self, x):
print("Not yet implemented for nn.Sequential")
exit(-1)
if __name__=="__main__":
print("This is a module and hence cannot be called directly ...")
print("A toy sample will now run ...")
from torch.autograd import Variable
import torch.nn.functional as F
import numpy
inputx=Variable(torch.Tensor(numpy.zeros([32,40])),requires_grad=True)
inputy=Variable(torch.Tensor(numpy.array(numpy.zeros([32,12]))),requires_grad=True)
inputz=Variable(torch.Tensor(numpy.array(numpy.zeros([32,20]))),requires_grad=True)
modalities=[inputx,inputy,inputz]
fmodel=RecurrentFusion([40,12,20],100)
out=fmodel(modalities,steps=5)
print("Output")
print(out[0])
print("Toy sample finished ...")
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmmodelsdk/fusion/recurrent_fusion/model.py |
EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmmodelsdk/fusion/tensor_fusion/__init__.py |
|
#CMU Multimodal SDK, CMU Multimodal Model SDK
#Tensor Fusion Network for Multimodal Sentiment Analysis, Amir Zadeh, Minghai Chen, Soujanya Poria, Erik Cambria, Louis-Philippe Morency - https://arxiv.org/pdf/1707.07250.pdf
#in_modalities: is a list of inputs from each modality - the first dimension of all the modality inputs must be the same, it will be the batch size. The second dimension is the feature dimension. There are a total of n modalities.
#out_dimension: the output of the tensor fusion
import torch
import time
from torch import nn
import torch.nn.functional as F
from six.moves import reduce
class TensorFusion(nn.Module):
def __init__(self,in_dimensions,out_dimension):
super(TensorFusion, self).__init__()
self.tensor_size=reduce(lambda x, y: x*y, in_dimensions)
self.linear_layer=nn.Linear(self.tensor_size,out_dimension)
self.in_dimensions=in_dimensions
self.out_dimension=out_dimension
def __call__(self,in_modalities):
return self.fusion(in_modalities)
def fusion(self,in_modalities):
bs=in_modalities[0].shape[0]
tensor_product=in_modalities[0]
#calculating the tensor product
for in_modality in in_modalities[1:]:
tensor_product=torch.bmm(tensor_product.unsqueeze(2),in_modality.unsqueeze(1))
tensor_product=tensor_product.view(bs,-1)
return self.linear_layer(tensor_product)
def forward(self, x):
print("Not yet implemented for nn.Sequential")
exit(-1)
if __name__=="__main__":
print("This is a module and hence cannot be called directly ...")
print("A toy sample will now run ...")
from torch.autograd import Variable
import torch.nn.functional as F
import numpy
inputx=Variable(torch.Tensor(numpy.zeros([32,40])),requires_grad=True)
inputy=Variable(torch.Tensor(numpy.array(numpy.zeros([32,12]))),requires_grad=True)
inputz=Variable(torch.Tensor(numpy.array(numpy.zeros([32,20]))),requires_grad=True)
modalities=[inputx,inputy,inputz]
fmodel=TensorFusion([40,12,20],100)
out=fmodel(modalities)
print("Output")
print(out[0])
print("Toy sample finished ...")
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmmodelsdk/fusion/tensor_fusion/model.py |
EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmmodelsdk/fusion/dynamic_fusion_graph/__init__.py |
|
#CMU Multimodal SDK, CMU Multimodal Model SDK
#Multimodal Language Analysis in the Wild: CMU-MOSEI Dataset and Interpretable Dynamic Fusion Graph, Amir Zadeh, Paul Pu Liang, Jonathan Vanbriesen, Soujanya Poria, Edmund Tong, Erik Cambria, Minghai Chen, Louis-Philippe Morency - http://www.aclweb.org/anthology/P18-1208
#pattern_model: a nn.Sequential model which will be used as core of the models inside the DFG
#in_dimensions: input dimensions of each modality
#out_dimension: output dimension of the pattern models
#efficacy_model: the core of the efficacy model
#in_modalities: inputs from each modality, the same order as in_dimensions
import torch
import time
from torch import nn
import torch.nn.functional as F
import copy
from six.moves import reduce
from itertools import chain,combinations
from collections import OrderedDict
class DynamicFusionGraph(nn.Module):
def __init__(self,pattern_model,in_dimensions,out_dimension,efficacy_model):
super(DynamicFusionGraph, self).__init__()
self.num_modalities=len(in_dimensions)
self.in_dimensions=in_dimensions
self.out_dimension=out_dimension
#in this part we sort out number of connections, how they will be connected etc.
self.powerset=list(chain.from_iterable(combinations(range(self.num_modalities), r) for r in range(self.num_modalities+1)))[1:]
#initializing the models inside the DFG
self.input_shapes={tuple([key]):value for key,value in zip(range(self.num_modalities),in_dimensions)}
self.networks={}
self.total_input_efficacies=0
for key in self.powerset[self.num_modalities:]:
#connections coming from the unimodal components
unimodal_dims=0
for modality in key:
unimodal_dims+=in_dimensions[modality]
multimodal_dims=((2**len(key)-2)-len(key))*out_dimension
self.total_input_efficacies+=2**len(key)-2
#for the network that outputs key component, what is the input dimension
final_dims=unimodal_dims+multimodal_dims
self.input_shapes[key]=final_dims
pattern_copy=copy.deepcopy(pattern_model)
final_model=nn.Sequential(*[nn.Linear(self.input_shapes[key],list(pattern_copy.children())[0].in_features),pattern_copy])
self.networks[key]=final_model
#finished construction weights, now onto the t_network which summarizes the graph
self.total_input_efficacies+=2**self.num_modalities-1
self.t_in_dimension=unimodal_dims+(2**self.num_modalities-(self.num_modalities)-1)*out_dimension
pattern_copy=copy.deepcopy(pattern_model)
self.t_network=nn.Sequential(*[nn.Linear(self.t_in_dimension,list(pattern_copy.children())[0].in_features),pattern_copy])
self.efficacy_model=nn.Sequential(*[nn.Linear(sum(in_dimensions),list(efficacy_model.children())[0].in_features),efficacy_model,nn.Linear(list(efficacy_model.children())[-1].out_features,self.total_input_efficacies)])
def __call__(self,in_modalities):
return self.fusion(in_modalities)
def fusion(self,in_modalities):
bs=in_modalities[0].shape[0]
outputs={}
for modality,index in zip(in_modalities,range(len(in_modalities))):
outputs[tuple([index])]=modality
efficacies=self.efficacy_model(torch.cat([x for x in in_modalities],dim=1))
efficacy_index=0
for key in self.powerset[self.num_modalities:]:
small_power_set=list(chain.from_iterable(combinations(key, r) for r in range(len(key)+1)))[1:-1]
this_input=torch.cat([outputs[x]*efficacies[:,efficacy_index+y].view(-1,1) for x,y in zip(small_power_set,range(len(small_power_set)))],dim=1)
outputs[key]=self.networks[key](this_input)
efficacy_index+=len(small_power_set)
small_power_set.append(tuple(range(self.num_modalities)))
t_input=torch.cat([outputs[x]*efficacies[:,efficacy_index+y].view(-1,1) for x,y in zip(small_power_set,range(len(small_power_set)))],dim=1)
t_output=self.t_network(t_input)
return t_output,outputs,efficacies
def forward(self, x):
print("Not yet implemented for nn.Sequential")
exit(-1)
if __name__=="__main__":
print("This is a module and hence cannot be called directly ...")
print("A toy sample will now run ...")
from torch.autograd import Variable
import torch.nn.functional as F
import numpy
inputx=Variable(torch.Tensor(numpy.array(numpy.zeros([32,40]))),requires_grad=True)
inputy=Variable(torch.Tensor(numpy.array(numpy.zeros([32,12]))),requires_grad=True)
inputz=Variable(torch.Tensor(numpy.array(numpy.zeros([32,20]))),requires_grad=True)
inputw=Variable(torch.Tensor(numpy.array(numpy.zeros([32,25]))),requires_grad=True)
modalities=[inputx,inputy,inputz,inputw]
#a simple linear function without any activations
pattern_model=nn.Sequential(nn.Linear(100,20))
efficacy_model=nn.Sequential(nn.Linear(100,20))
fmodel=DynamicFusionGraph(pattern_model,[40,12,20,25],20,efficacy_model)
out=fmodel(modalities)
print("Output")
print(out[0].shape,out[2].shape)
print("Toy sample finished ...")
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmmodelsdk/fusion/dynamic_fusion_graph/model.py |
from LSTHM.LSTHM import LSTHM as LSTHM
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmmodelsdk/modules/__init__.py |
import torch
import time
from torch import nn
import torch.nn.functional as F
class LSTHM(nn.Module):
def __init__(self,cell_size,in_size,hybrid_in_size):
super(LSTHM, self).__init__()
self.cell_size=cell_size
self.in_size=in_size
self.W=nn.Linear(in_size,4*self.cell_size)
self.U=nn.Linear(cell_size,4*self.cell_size)
self.V=nn.Linear(hybrid_in_size,4*self.cell_size)
def step(self,x,ctm1,htm1,ztm1):
input_affine=self.W(x)
output_affine=self.U(htm1)
hybrid_affine=self.V(ztm1)
sums=input_affine+output_affine+hybrid_affine
#biases are already part of W and U and V
f_t=F.sigmoid(sums[:,:self.cell_size])
i_t=F.sigmoid(sums[:,self.cell_size:2*self.cell_size])
o_t=F.sigmoid(sums[:,2*self.cell_size:3*self.cell_size])
ch_t=F.tanh(sums[:,3*self.cell_size:])
c_t=f_t*ctm1+i_t*ch_t
h_t=F.tanh(c_t)*o_t
return c_t,h_t
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmmodelsdk/modules/LSTHM/LSTHM.py |
EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmmodelsdk/modules/LSTHM/__init__.py |
|
import torch
from torch import nn
from torch.autograd import Variable
import torch.nn.functional as F
from LSTHM import LSTHM
import numpy
#in=40, 3 modalities,4 attentions
full_in=numpy.array(numpy.zeros([32,40]))
inputx=Variable(torch.Tensor(full_in),requires_grad=True)
full_in=numpy.array(numpy.zeros([32,12]))
inputy=Variable(torch.Tensor(full_in),requires_grad=True)
full_in=numpy.array(numpy.zeros([32,12]))
inputc=Variable(torch.Tensor(full_in),requires_grad=True)
full_in=numpy.array(numpy.zeros([32,20]))
inputz=Variable(torch.Tensor(full_in),requires_grad=True)
fmodel=LSTHM(12,40,20)
c,h=fmodel.step(inputx,inputc,inputy,inputz)
print(c.shape,h.shape)
#a=numpy.array([[1,2,3],[4,5,6]])
#b=Variable(torch.Tensor(a))
#c=b.repeat(1,2)
#print(c.shape)
#print(F.softmax(c,dim=1))
#print(c.view(2,2,3)[0,1,:])
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmmodelsdk/modules/LSTHM/test.py |
from mmsdk.mmdatasdk.computational_sequence.computational_sequence import computational_sequence as computational_sequence
from mmsdk.mmdatasdk.dataset.dataset import mmdataset as mmdataset
from mmsdk.mmdatasdk.dataset.standard_datasets import CMU_MOSEI as cmu_mosei
from mmsdk.mmdatasdk.dataset.standard_datasets import CMU_MOSI as cmu_mosi
from mmsdk.mmdatasdk.dataset.standard_datasets import POM as pom
from mmsdk.mmdatasdk.dataset.standard_datasets import SocialIQ as socialiq
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/__init__.py |
featuresetMetadataTemplate= [
"root name",#name of the featureset
"computational sequence description",#name of the featureset
"dimension names"
"computational sequence version",#the version of featureset
"alignment compatible",#name of the featureset
"dataset name",#featureset belongs to which dataset
"dataset version",#the version of dataset
"creator",#the author of the featureset
"contact",#the contact of the featureset
"featureset bib citation",#citation for the paper related to this featureset
"dataset bib citation"#citation for the dataset
]
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/configurations/metadataconfigs.py |
EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/configurations/__init__.py |
|
from mmsdk.mmdatasdk import log
from mmsdk.mmdatasdk.configurations.metadataconfigs import *
from tqdm import tqdm
#this function checks the heirarchy format of a given computatioanl sequence data. This will crash the program if data is in wrong format. If in correct format the return value is simply True
def validate_data_format(data,root_name,verbose=True):
log.status("Checking the format of the data in <%s> computational sequence ..."%root_name)
pbar = log.progress_bar(total=len(data.keys()),unit=" Computational Sequence Entries",leave=False)
failure=False
if (type(data) is not dict):
#this will cause the rest of the pipeline to crash - RuntimeError
log.error("%s computational sequence data is not in heirarchy format ...",error=True)
try:
#for each video check the shapes of the intervals and features
for vid in data.keys():
#check the intervals first - if failure simply show a warning - no exit since we want to identify all the cases
if len(data[vid]["intervals"].shape) != 2 :
if verbose: log.error("Video <%s> in <%s> computational sequence has wrong intervals array shape. "%(vid,root_name),error=False)
failure=True
#check the features next
if len(data[vid]["features"].shape) < 2 :
if verbose: log.error("Video <%s> in <%s> computational sequence has wrong features array shape. "%(vid,root_name),error=False)
failure=True
#if the first dimension of intervals and features doesn't match
if data[vid]["features"].shape[0] != data[vid]["intervals"].shape[0]:
if verbose: log.error("Video <%s> in <%s> computational sequence - features and intervals have different first dimensions. "%(vid,root_name),error=False)
failure=True
pbar.update(1)
#some other thing has happened! - RuntimeError
except:
if verbose:
log.error("<%s> computational sequence data format could not be checked. "%root_name,error=True)
pbar.close()
pbar.close()
#failure during intervals and features check
if failure:
log.error("<%s> computational sequence data integrity check failed due to inconsistency in intervals and features. "%root_name,error=True)
else:
log.success("<%s> computational sequence data in correct format." %root_name)
return True
#this function checks the computatioanl sequence metadata. This will not crash the program if metadata is missing. If metadata is there the return value is simply True
def validate_metadata_format(metadata,root_name,verbose=True):
log.status("Checking the format of the metadata in <%s> computational sequence ..."%root_name)
failure=False
if type(metadata) is not dict:
log.error("<%s> computational sequence metadata is not key-value pairs!", error=True)
presenceFlag=[mtd in metadata.keys() for mtd in featuresetMetadataTemplate]
#check if all the metadata is set
if all (presenceFlag) is False:
#verbose one is not set
if verbose:
missings=[x for (x,y) in zip (featuresetMetadataTemplate,presenceFlag) if y is False]
log.error("Missing metadata in <%s> computational sequence: %s"%(root_name,str(missings)),error=False)
failure=True
if failure:
log.error(msgstring="<%s> computational sequence does not have all the required metadata ... continuing "%root_name,error=False)
return False
else:
log.success("<%s> computational sequence metadata in correct format."%root_name)
return True
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/computational_sequence/integrity_check.py |
import h5py
import hashlib
import validators
import json
import sys
import os
import time
import uuid
#log is the same as standard_sdks log
from mmsdk.mmdatasdk import log
from mmsdk.mmdatasdk.configurations.metadataconfigs import *
from mmsdk.mmdatasdk.computational_sequence.integrity_check import *
from mmsdk.mmdatasdk.computational_sequence.blank import *
from mmsdk.mmdatasdk.computational_sequence.file_ops import *
from mmsdk.mmdatasdk.computational_sequence.download_ops import *
#computational sequence class
#main attributes:
# main_file: where the location of the heirarchical data binary file is
# resource: where the heirarchical data comes from (i.e. a URL)
# h5handle: handle to the file
# data: the data in a dictionary format
# metadata: the metadata in a dictionary format
#
#main function:
# completeAllMissingMetadata: a helper to complete all the missing metadata
# deploy: deploy the computational sequence - you can also notify multicomp about your computational sequence
class computational_sequence():
def __init__(self,resource, destination=None, validate=True):
#initializing the featureset
self.__initialize(resource,destination,validate)
#BACKWARD: backward compatibility
self.rootName=self.root_name
def _compare_entries(self,entry1,entry2):
return entry1.split('[')[0]==entry2.split('[')[0]
def __getitem__(self, key):
return self.data[key]
def __setitem__(self,key,value):
self.data[key]={}
self.data[key]["intervals"]=value["intervals"]
self.data[key]["features"]=value["features"]
def keys(self):
return self.data.keys()
def _remove_id(self,entry_id,purge=False):
if purge==False:
if entry_id in list(self.data.keys()):
del self.data[entry_id]
elif purge==True:
keys_to_del=[key for key in list(self.keys()) if key[:len(entry_id)]==entry_id]
for key_to_del in keys_to_del:
del self.data[key_to_del]
else:
log.error("Purge received wrong argument type. Exiting ...!",error=True)
def __initialize_from_csd(self,resource,destination,validate):
if validators.url(resource):
#user would like to store to the current directory
if destination is None or destination == '':
destination=os.path.join('./',resource.split(os.sep)[-1])
#user has chosen a different directory
elif '.csd' not in destination:
destination=os.path.join(destination,resource.split(os.sep)[-1])
#.csd cannot be in the destination as we don't allow name changes when downloading
else:
log.error("Destination needs to be a folder where the downloaded computational sequence is stored. Exiting ...!",error=True)
read_URL(resource,destination)
self.resource=resource
self.main_file=destination
else:
self.main_file=resource
h5handle,data,metadata=read_CSD(self.main_file)
if type(metadata) is not dict:
log.error("Metadata not in correct format for %s. Exiting ...!"%destination,error=True)
self.data=data
self.metadata=metadata
self.root_name=self.metadata["root name"]
self.h5handle=h5handle
if validate:
self.__check_format()
else:
log.warning("Validation of the computational sequence skipped by user request.")
def __initialize_blank(self,root_name):
self.main_file=None
self.h5handle=None
self.root_name=root_name
self.data={}
self.metadata={}
self.metadata["root name"]=root_name
log.success("Initialized empty <%s> computational sequence."%self.metadata["root name"])
#TODO: try and excepts to be added to this code
def __initialize(self,resource,destination,validate):
#computational sequence is already initialized
if hasattr(self,'h5handle'): log.error("<%s> computational sequence already initialized ..."%self.metadata["root name"],error=True)
#initializing blank - main_file is where to initialize the data and resource is None since the data comes from nowhere
if '.csd' not in resource:
self.__initialize_blank(resource)
#reading from url or folder - main_file is where the data should go and resource is the url
else:
self.__initialize_from_csd(resource,destination,validate)
#checking if the data and metadata are in correct format
#stops the program if the integrity is not ok
def __check_format(self,error=True):
if not hasattr(self,'metadata') or not hasattr(self,'data'):
log.error("computational sequence is blank (data or metadata is missing)")
log.status("Checking the integrity of the <%s> computational sequence ..."%self.metadata["root name"])
#TODO: hash check not implemented yet
datavalid=validate_data_format(self.data,self.metadata["root name"],verbose=False)
metadatavalid=validate_metadata_format(self.metadata,self.metadata["root name"],verbose=False)
if datavalid and metadatavalid:
log.success("<%s> computational sequence is valid!"%self.metadata["root name"])
#set the metadata for all the missing information in the metadata. If the key is not set then the assumption is that metadata is not available. Note that if the metadata is set to a dummy variable like None then it is still considered set.
def complete_all_missing_metadata(self):
missings=[x for (x,y) in zip(featuresetMetadataTemplate,[metadata in self.metadata.keys() for metadata in featuresetMetadataTemplate]) if y is False]
#python2 vs python 3
#TODO: Add read from file
root_name_ext=''
if hasattr(self,"root_name"):
root_name_ext=" for <%s> computational sequence"%self.root_name
for missing in missings:
self.metadata[missing]=log.status("Please input %s%s: "%(missing,root_name_ext),require_input=True)
#BACKWARD: _ for backward compability
def set_data(self,data,_=None,__=None):
validate_data_format(data,self.root_name,verbose=True)
self.data=data
#BACKWARD: _ for backward compability
def set_metadata(self,metadata,_=None,__=None):
validate_metadata_format(metadata,self.root_name,verbose=False)
self.metadata=metadata
#writing the file to the output
def deploy(self,destination,compression="gzip",compression_opts=9,full_chunk_shape=True):
self.complete_all_missing_metadata()
self.__check_format()
log.status("Deploying the <%s> computational sequence to %s"%(destination,self.metadata['root name']))
#generating the unique identifiers
self.metadata['uuid']=str(uuid.uuid4())
#TODO: add SHA256 check + midification should not be possible without private key
self.metadata['md5']=None
log.status("Your unique identifier for <%s> computational sequence is %s"%(self.metadata["root name"],self.metadata['uuid']))
write_CSD(self.data,self.metadata,self.metadata["root name"],destination,compression=compression,compression_opts=compression_opts,full_chunk_shape=full_chunk_shape)
self.main_file=destination
def _get_entries_stripped(self):
return list(set([entry.split('[')[0] for entry in list(self.data.keys())]))
def bib_citations(self,outfile=None):
outfile=sys.stdout if outfile is None else outfile
if self.metadata is None or self.metadata=={}:
log.error("Metadata is not set for <%s> computational sequence"%self.root_name)
outfile.write('Computational Sequence <%s> bib: '%self.root_name+self.metadata['featureset bib citation']+'\n\n')
outfile.write('Dataset <%s> bib: '%self.metadata["dataset name"]+self.metadata['dataset bib citation']+'\n\n')
#some backward compatibility stuff.
computational_sequence.setData=computational_sequence.set_data
computational_sequence.setMetadata=computational_sequence.set_metadata
computational_sequence.completeAllMissingMetadata=computational_sequence.complete_all_missing_metadata
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/computational_sequence/computational_sequence.py |
import sys
import h5py
import os
import json
from tqdm import tqdm
from mmsdk.mmdatasdk import log
from mmsdk.mmdatasdk.configurations.metadataconfigs import *
from mmsdk.mmdatasdk.computational_sequence.integrity_check import *
def read_CSD(resource,destination=None):
if (resource is None): raise log.error("No resource specified for computational sequence!",error=True)
if os.path.isfile(resource) is False:
log.error("%s file not found, please check the path ..."%resource,error=True)
try:
h5handle=h5py.File('%s'%resource,'r')
except:
raise log.error("%s resource is not a valid hdf5 computational sequence format ..."%resource,error=True)
log.success ("Computational sequence read from file %s ..."%resource)
return h5handle,dict(h5handle[list(h5handle.keys())[0]]["data"]),metadata_to_dict(h5handle[list(h5handle.keys())[0]]["metadata"])
#writing CSD files to disk
def write_CSD(data,metadata,rootName,destination,compression,compression_opts,full_chunk_shape):
log.status("Writing the <%s> computational sequence data to %s"%(rootName,destination))
if compression is not None:
log.advise("Compression with %s and opts -%d"%(compression,compression_opts))
#opening the file
writeh5Handle=h5py.File(destination,'w')
#creating the root handle
rootHandle=writeh5Handle.create_group(rootName)
#writing the data
dataHandle=rootHandle.create_group("data")
pbar = log.progress_bar(total=len(data.keys()),unit=" Computational Sequence Entries",leave=False)
for vid in data:
vidHandle=dataHandle.create_group(vid)
if compression is not None:
vidHandle.create_dataset("features",data=data[vid]["features"],compression=compression,compression_opts=compression_opts)
vidHandle.create_dataset("intervals",data=data[vid]["intervals"],compression=compression,compression_opts=compression_opts)
else:
vidHandle.create_dataset("features",data=data[vid]["features"])
vidHandle.create_dataset("intervals",data=data[vid]["intervals"])
pbar.update(1)
pbar.close()
log.success("<%s> computational sequence data successfully wrote to %s"%(rootName,destination))
log.status("Writing the <%s> computational sequence metadata to %s"%(rootName,destination))
#writing the metadata
metadataHandle=rootHandle.create_group("metadata")
for metadataKey in metadata.keys():
metadataHandle.create_dataset(metadataKey,(1,),dtype=h5py.special_dtype(vlen=unicode) if sys.version_info.major is 2 else h5py.special_dtype(vlen=str))
cast_operator=unicode if sys.version_info.major is 2 else str
metadataHandle[metadataKey][0]=cast_operator(json.dumps(metadata[metadataKey]))
writeh5Handle.close()
log.success("<%s> computational sequence metadata successfully wrote to %s"%(rootName,destination))
log.success("<%s> computational sequence successfully wrote to %s ..."%(rootName,destination))
def metadata_to_dict(metadata_):
if (type(metadata_) is dict):
return metadata_
else:
metadata={}
for key in metadata_.keys():
try:
metadata[key]=json.loads(metadata_[key][0])
except:
try:
metadata[key]=str(metadata_[key][0])
except:
log.error("Metadata %s is in wrong format. Exiting ...!"%key)
return metadata
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/computational_sequence/file_ops.py |
EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/computational_sequence/__init__.py |
|
import h5py
import time
import requests
from tqdm import tqdm
import os
import math
import sys
from mmsdk.mmdatasdk import log
def read_URL(url,destination):
if destination is None:
log.error("Destination is not specified when downloading data",error=True)
if os.path.isdir(destination.rsplit(os.sep,1)[-2]) is False:
os.mkdir(destination.rsplit(os.sep,1)[-2])
if(os.path.isfile(destination)):
log.error("%s file already exists ..."%destination,error=True)
r = requests.get(url, stream=True)
if r.status_code != 200:
log.error('URL: %s does not exist'%url,error=True)
# Total size in bytes.
total_size = int(r.headers.get('content-length', 0));
block_size = 1024
unit=total_size/block_size
wrote = 0
with open(destination, 'wb') as f:
log.status("Downloading from %s to %s..."%(url,destination))
pbar=log.progress_bar(total=math.ceil(total_size//block_size),data=r.iter_content(block_size),postfix="Total in kBs",unit='kB', leave=False)
for data in pbar:#unit_scale=True,
wrote = wrote + len(data)
f.write(data)
pbar.close()
if total_size != 0 and wrote != total_size:
log.error("Error downloading the data to %s ..."%destination,error=True)
log.success("Download complete!")
return True
if __name__=="__main__":
readURL("http://immortal.multicomp.cs.cmu.edu/CMU-MOSEI/acoustic/CMU_MOSEI_COVAREP.csd","./hi.csd")
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/computational_sequence/download_ops.py |
EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/computational_sequence/blank.py |
|
EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/dataset/__init__.py |
|
from mmsdk.mmdatasdk import log, computational_sequence
import sys
import numpy
import time
from tqdm import tqdm
import os
#specified for numerical inconsistencies within floating points - if abs l1 distance two numbers is less than this, then they are the same.
#only use for interval comparison.
epsilon=10e-6
class mmdataset:
def __init__(self,recipe,destination=None):
self.computational_sequences={}
if type(recipe) is str:
if os.path.isdir(recipe) is False:
log.error("Dataset folder does not exist ...",error=True)
from os import listdir
from os.path import isfile, join
computational_sequence_list = [f for f in listdir(recipe) if isfile(join(recipe, f)) and f[-4:]=='.csd']
for computational_sequence_fname in computational_sequence_list:
this_sequence=computational_sequence(join(recipe,computational_sequence_fname))
self.computational_sequences[this_sequence.metadata["root name"]]=this_sequence
elif type(recipe) is dict:
for entry, address in recipe.items():
self.computational_sequences[entry]=computational_sequence(address,destination)
elif type(recipe) is list:
#TODO: computational sequence with uuid
pass
else:
log.error("Cannot create a dataset with the given recipe. Exiting ...!",error=True)
if len(self.computational_sequences.keys())==0:
log.error("Dataset failed to initialize ...", error=True)
log.success("Dataset initialized successfully ... ")
def __getitem__(self,key):
if key not in list(self.computational_sequences.keys()):
log.error("Computational sequence does not exist ...",error=True)
return self.computational_sequences[key]
def keys(self):
return self.computational_sequences.keys()
def add_computational_sequences(self,recipe,destination):
for entry, address in recipe.items():
if entry in self.computational_sequences:
log.error("Dataset already contains <%s> computational sequence ..."%entry)
self.computational_sequences[entry]=computational_sequence(address,destination)
def bib_citations(self,outfile=None):
outfile=sys.stdout if outfile is None else outfile
sdkbib='@article{zadeh2018multi, title={Multi-attention recurrent network for human communication comprehension}, author={Zadeh, Amir and Liang, Paul Pu and Poria, Soujanya and Vij, Prateek and Cambria, Erik and Morency, Louis-Philippe}, journal={arXiv preprint arXiv:1802.00923}, year={2018}}'
outfile.write('mmsdk bib: '+sdkbib+'\n\n')
for entry,compseq in self.computational_sequences.items():
compseq.bib_citations(outfile)
def unify(self,active=True):
log.status("Unify was called ...")
all_vidids={}
violators=[]
all_keys={}
for seq_key in list(self.computational_sequences.keys()):
all_keys[seq_key]=[vidid.split("[")[0] for vidid in self.computational_sequences[seq_key].data.keys()]
valids=set.intersection(*[set(all_keys[x]) for x in all_keys])
violators=set()
for seq_key in list(self.computational_sequences.keys()):
violators=violators.union(set([vidid.split("[")[0] for vidid in self.computational_sequences[seq_key].data.keys()])-valids)
if len(violators) >0 :
for violator in violators:
log.error("%s entry is not shared among all sequences, removing it ..."%violator,error=False)
if active==True:
self.remove_id(violator,purge=True)
if active==False and len(violators)>0:
log.error("%d violators remain, alignment will fail if called ..."%len(violators),error=True)
log.success("Unify completed ...")
def hard_unify(self,active=True):
log.status("Hard unify was called ...")
all_vidids={}
violators=[]
all_keys={}
for seq_key in list(self.computational_sequences.keys()):
all_keys[seq_key]=[vidid for vidid in self.computational_sequences[seq_key].data.keys()]
valids=set.intersection(*[set(all_keys[x]) for x in all_keys])
for seq_key in list(self.computational_sequences.keys()):
hard_unify_compatible=all(["[" in vidid for vidid in self.computational_sequences[seq_key].data.keys()])
if hard_unify_compatible is False:
log.error("Hard unify can only be done on aligned computational sequences, %s violated this ... Exiting ..."%seq_key)
violators=set([vidid for vidid in self.computational_sequences[seq_key].data.keys()])-valids
for violator in violators:
if active==True:
log.error("%s entry is not shared among all sequences, removing it ..."%violator,error=False)
self[seq_key]._remove_id(violator,purge=False)
if active==False and len(violators)>0:
log.error("%d violators remain, alignment will fail if called ..."%len(violators),error=True)
log.success("Hard unify completed ...")
def remove_id(self,entry_id,purge=False):
for key,compseq in self.computational_sequences.items():
compseq._remove_id(entry_id,purge=purge)
def align(self,reference,collapse_functions=None,replace=True):
aligned_output={}
for sequence_name in self.computational_sequences.keys():
aligned_output[sequence_name]={}
if reference not in self.computational_sequences.keys():
log.error("Computational sequence <%s> does not exist in dataset"%reference,error=True)
refseq=self.computational_sequences[reference].data
#unifying the dataset, removing any entries that are not in the reference computational sequence
self.unify()
#building the relevant entries to the reference - what we do in this section is simply removing all the [] from the entry ids and populating them into a new dictionary
log.status("Pre-alignment based on <%s> computational sequence started ..."%reference)
relevant_entries=self.__get_relevant_entries(reference)
log.status("Alignment starting ...")
pbar = log.progress_bar(total=len(refseq.keys()),unit=" Computational Sequence Entries",leave=False)
pbar.set_description("Overall Progress")
for entry_key in list(refseq.keys()):
pbar_small=log.progress_bar(total=refseq[entry_key]['intervals'].shape[0],unit=" Segments",leave=False)
pbar_small.set_description("Aligning %s"%entry_key)
for i in range(refseq[entry_key]['intervals'].shape[0]):
#interval for the reference sequence
ref_time=refseq[entry_key]['intervals'][i,:]
#we drop zero or very small sequence lengths - no align for those
if (abs(ref_time[0]-ref_time[1])<epsilon):
pbar_small.update(1)
continue
#aligning all sequences (including ref sequence) to ref sequence
for otherseq_key in list(self.computational_sequences.keys()):
if otherseq_key != reference:
intersects,intersects_features=self.__intersect_and_copy(ref_time,relevant_entries[otherseq_key][entry_key],epsilon)
else:
intersects,intersects_features=refseq[entry_key]['intervals'][i,:][None,:],refseq[entry_key]['features'][i,:][None,:]
#there were no intersections between reference and subject computational sequences for the entry
if intersects.shape[0] == 0:
continue
#collapsing according to the provided functions
if type(collapse_functions) is list:
intersects,intersects_features=self.__collapse(intersects,intersects_features,collapse_functions)
if(intersects.shape[0]!=intersects_features.shape[0]):
log.error("Dimension mismatch between intervals and features when aligning <%s> computational sequences to <%s> computational sequence"%(otherseq_key,reference),error=True)
aligned_output[otherseq_key][entry_key+"[%d]"%i]={}
aligned_output[otherseq_key][entry_key+"[%d]"%i]["intervals"]=intersects
aligned_output[otherseq_key][entry_key+"[%d]"%i]["features"]=intersects_features
pbar_small.update(1)
pbar_small.close()
pbar.update(1)
pbar.close()
log.success("Alignment to <%s> complete."%reference)
if replace is True:
log.status("Replacing dataset content with aligned computational sequences")
self.__set_computational_sequences(aligned_output)
return None
else:
log.status("Creating new dataset with aligned computational sequences")
newdataset=mmdataset({})
newdataset.__set_computational_sequences(aligned_output,metadata_copy=False)
return newdataset
def __collapse(self,intervals,features,functions):
#we simply collapse the intervals to (1,2) matrix
new_interval=numpy.array([[intervals.min(),intervals.max()]])
try:
new_features=numpy.concatenate([function(intervals,features) for function in functions],axis=0)
if len(new_features.shape)==1:
new_features=new_features[None,:]
except:
log.error("Cannot collapse given the set of functions. Please check for exceptions in your functions ...", error=True)
return new_interval,new_features
#TODO: This is not passive-align safe
def revert(self,replace=True):
reverted_dataset={x:{} for x in self.keys()}
log.status("Revert was called ...")
if len(self.keys())==0:
log.error("The dataset contains no computational sequences ... Exiting!",error=True)
self.hard_unify()
all_keys=list(self[list(self.keys())[0]].keys())
if len(all_keys)==0:
log.error("No entries in computational sequences or removed during unify ... Exiting!")
unique_unnumbered_entries={}
for key in all_keys:
if key.split('[')[0] not in unique_unnumbered_entries:
unique_unnumbered_entries[key.split('[')[0]]=[]
unique_unnumbered_entries[key.split('[')[0]].append(int(key.split('[')[1][:-1]))
pbar = tqdm(total=len(unique_unnumbered_entries.keys()),unit=" Unique Sequence Entries",leave=False)
pbar.set_description("Reversion Progress")
for key in unique_unnumbered_entries.keys():
unique_unnumbered_entries[key].sort()
for cs_key in reverted_dataset.keys():
intervals=numpy.concatenate([self[cs_key][str('%s[%d]'%(key,i))]["intervals"] for i in unique_unnumbered_entries[key]],axis=0)
features=numpy.concatenate([self[cs_key][str('%s[%d]'%(key,i))]["features"] for i in unique_unnumbered_entries[key]],axis=0)
reverted_dataset[cs_key][key]={"intervals":intervals,"features":features}
pbar.update(1)
pbar.close()
log.success("Reversion completed ...")
if replace is True:
log.status("Replacing dataset content with reverted computational sequences")
self.__set_computational_sequences(reverted_dataset)
return None
else:
log.status("Creating new dataset with reverted computational sequences")
newdataset=mmdataset({})
newdataset.__set_computational_sequences(reverted_dataset,metadata_copy=False)
return newdataset
def impute(self,ref_key,imputation_fn=numpy.zeros):
log.status("Imputation called with function: %s ..."%str(imputation_fn.__name__))
other_keys=list(self.keys())
other_keys.remove(ref_key)
other_keys_dims={x:list(self[x][list(self[x].keys())[0]]["features"].shape[1:]) for x in other_keys}
pbar = tqdm(total=len(self[ref_key].keys()),unit=" Reference Computational Sequence Entries",leave=False)
pbar.set_description("Imputation Progress")
for seg_key in self[ref_key].keys():
for other_key in other_keys:
try:
self[other_key][seg_key]
except:
num_entries=self[ref_key][seg_key]["intervals"].shape[0]
self[other_key][seg_key]={"intervals":self[ref_key][seg_key]["intervals"],"features":imputation_fn([num_entries]+other_keys_dims[other_key])}
#log.status("Imputing %s,%s with function %s"%(other_key,seg_key,str(imputation_fn.__name__)))
pbar.update(1)
pbar.close()
log.success("Imputation completed ...")
#setting the computational sequences in the dataset based on a given new_computational_sequence_data - may copy the metadata if there is already one
def __set_computational_sequences(self,new_computational_sequences_data,metadata_copy=True):
#getting the old metadata from the sequence before replacing it. Even if this is a new computational sequence this will not cause an issue since old_metadat will just be empty
old_metadata={m:self.computational_sequences[m].metadata for m in list(self.computational_sequences.keys())}
self.computational_sequences={}
for sequence_name in list(new_computational_sequences_data.keys()):
self.computational_sequences[sequence_name]=computational_sequence(sequence_name)
self.computational_sequences[sequence_name].setData(new_computational_sequences_data[sequence_name],sequence_name)
if metadata_copy:
#if there is no metadata for this computational sequences from the previous one or no previous computational sequenece
if sequence_name not in list(old_metadata.keys()):
log.error ("Metadata not available to copy ..., please provide metadata before writing to disk later", error =False)
self.computational_sequences[sequence_name].setMetadata(old_metadata[sequence_name],sequence_name)
self.computational_sequences[sequence_name].rootName=sequence_name
def deploy(self,destination,filenames):
if os.path.isdir(destination) is False:
os.mkdir(destination)
for seq_key in list(self.computational_sequences.keys()):
if seq_key not in list(filenames.keys()):
log.error("Filename for %s computational sequences not specified"%seq_key)
filename=filenames[seq_key]
if filename [:-4] != '.csd':
filename+='.csd'
self.computational_sequences[seq_key].deploy(os.path.join(destination,filename))
def sort(self,sort_function=sorted):
""" Sorts the computational sequence data based on the start time in intervals
#Arguments
self: The dataset object.
sort_function: The function passed for sorting. This function will receive the intervals one by one for each key
#Returns
Does not return any values - replaces in place
"""
for key in list(self.keys()):
for csd in list(self[key].keys()):
this_intervals_np=numpy.array(self[key][csd]["intervals"])
this_features_np=numpy.array(self[key][csd]["features"])
sorted_indices=sort_function(range(this_intervals_np.shape[0]),key=lambda x: this_intervals_np[x,0])
sorted_this_intervals_np=this_intervals_np[sorted_indices,:]
sorted_this_features_np=this_features_np[sorted_indices,:]
self[key][csd]["intervals"]=sorted_this_intervals_np
self[key][csd]["features"]=sorted_this_features_np
#TODO: Add folds to this function
def get_tensors(self,seq_len,non_sequences=[],direction=False,folds=None):
""" Returns trainable tensor from computational sequence data
#Arguments
self: The dataset object.
seq_len: The maximum sequence length for the computational sequence entries, e.g. sentence length in words.
direction: True for right padding and False for left padding.
folds: The folds in which the dataset should be split.
#Returns
Dictionary of numpy arrays with the same data type as computational sequences. Dictionaries include the same keys as the dataset
"""
csds=list(self.keys())
def handle_none_folds():
return_folds={}
for key in list(self[csds[0]].keys()):
return_folds[key.split("[")[0]]=None
return [list(return_folds.keys())]
if folds==None:
log.error("No fold specified for get_tensors, defaulting to the first computational sequence ids",error=False)
folds=handle_none_folds()
self.hard_unify()
data=[]
output=[]
for i in range (len(folds)):
data.append({})
output.append({})
def lpad(this_array,direction):
if direction==False:
temp_array=numpy.concatenate([numpy.zeros([seq_len]+list(this_array.shape[1:])),this_array],axis=0)[-seq_len:,...]
else:
temp_array=numpy.concatenate([this_array,numpy.zeros([seq_len]+list(this_array.shape[1:]))],axis=0)[:seq_len,...]
return temp_array
def detect_entry_fold(entry,folds):
entry_id=entry.split("[")[0]
for i in range(len(folds)):
if entry_id in folds[i]: return i
return None
if len(csds)==0:
log.error("Dataset is empty, cannot get tensors. Exiting ...!",error=True)
for i in range (len(folds)):
for csd in csds:
data[i][csd]=[]
for key in list(self[csds[0]].keys()):
which_fold=detect_entry_fold(key,folds)
if which_fold==None:
log.error("Key %s doesn't belong to any fold ... "%str(key),error=False)
continue
for csd in list(self.keys()):
this_array=self[csd][key]["features"]
if csd in non_sequences:
data[which_fold][csd].append(this_array)
else:
data[which_fold][csd].append(lpad(this_array,direction))
for i in range(len(folds)):
for csd in csds:
output[i][csd]=numpy.array(data[i][csd])
return output
def __intersect_and_copy(self,ref,relevant_entry,epsilon):
sub=relevant_entry["intervals"]
features=relevant_entry["features"]
#copying and inverting the ref
ref_copy=ref.copy()
ref_copy[1]=-ref_copy[1]
ref_copy=ref_copy[::-1]
sub_copy=sub.copy()
sub_copy[:,0]=-sub_copy[:,0]
#finding where intersect happens
where_intersect=(numpy.all((sub_copy-ref_copy)>(-epsilon),axis=1)==True)
intersectors=sub[where_intersect,:]
intersectors=numpy.concatenate([numpy.maximum(intersectors[:,0],ref[0])[:,None],numpy.minimum(intersectors[:,1],ref[1])[:,None]],axis=1)
intersectors_features=features[where_intersect,:]
#checking for boundary cases and also zero length
where_nonzero_len=numpy.where(abs(intersectors[:,0]-intersectors[:,1])>epsilon)
intersectors_final=intersectors[where_nonzero_len]
intersectors_features_final=intersectors_features[where_nonzero_len]
return intersectors_final,intersectors_features_final
#TODO: Need tqdm bar for this as well
def __get_relevant_entries(self,reference):
relevant_entries={}
relevant_entries_np={}
#pbar = tqdm(total=count,unit=" Computational Sequence Entries",leave=False)
for otherseq_key in set(list(self.computational_sequences.keys()))-set([reference]):
relevant_entries[otherseq_key]={}
relevant_entries_np[otherseq_key]={}
sub_compseq=self.computational_sequences[otherseq_key]
for key in list(sub_compseq.data.keys()):
keystripped=key.split('[')[0]
if keystripped not in relevant_entries[otherseq_key]:
relevant_entries[otherseq_key][keystripped]={}
relevant_entries[otherseq_key][keystripped]["intervals"]=[]
relevant_entries[otherseq_key][keystripped]["features"]=[]
relev_intervals=self.computational_sequences[otherseq_key].data[key]["intervals"]
relev_features=self.computational_sequences[otherseq_key].data[key]["features"]
if len(relev_intervals.shape)<2:
relev_intervals=relev_intervals[None,:]
relev_features=relev_features[None,:]
relevant_entries[otherseq_key][keystripped]["intervals"].append(relev_intervals)
relevant_entries[otherseq_key][keystripped]["features"].append(relev_features)
for key in list(relevant_entries[otherseq_key].keys()):
relev_intervals_np=numpy.concatenate(relevant_entries[otherseq_key][key]["intervals"],axis=0)
relev_features_np=numpy.concatenate(relevant_entries[otherseq_key][key]["features"],axis=0)
sorted_indices=sorted(range(relev_intervals_np.shape[0]),key=lambda x: relev_intervals_np[x,0])
relev_intervals_np=relev_intervals_np[sorted_indices,:]
relev_features_np=relev_features_np[sorted_indices,:]
relevant_entries_np[otherseq_key][key]={}
relevant_entries_np[otherseq_key][key]["intervals"]=relev_intervals_np
relevant_entries_np[otherseq_key][key]["features"]=relev_features_np
log.status("Pre-alignment done for <%s> ..."%otherseq_key)
return relevant_entries_np
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/dataset/dataset.py |
EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/dataset/standard_datasets/__init__.py |
|
standard_train_fold=['202990', '116221', '110003', '265302', '33089', '286943', '122439', '126872', '43371', '81406', '246216', '41381', '118639', '121759', '193894', '106077', '193291', '100367', '79356', '241172', '112604', '202431', '127470', '241178', '193093', '52067', '112172', '264418', '238060', '238063', '214095', '127490', '270254', '71987', '16145', '266366', '237363', '342407', '29751', '81538', '29758', '243797', '230422', '223883', '276217', '137827', '223885', '102184', '224772', '113265', '275267', '57294', '25522', '243341', '272838', '136647', '94983', '98505', '135623', '194625', '17622', '74532', '97908', '22719', '245276', '270665', '233939', '57598', '86494', '229296', '42426', '57618', '58554', '78752', '238100', '19573', '89951', '72017', '233366', '34989', '220548', '218757', '327283', '216857', '270449', '139006', '270444', '187033', '98187', '224599', '238683', '22901', '93843', '133888', '230692', '128752', '47797', '119397', '204085', '38387', '208322', '15138', '252177', '48300', '254298', '192799', '105537', '92291', '88245', '90008', '126831', '203466', '130426', '239572', '53609', '49264', '273207', '46860', '247382', '190726', '342197', '87434', '209775', '106037', '21727', '232464', '224292', '234046', '22305', '28142', '210259', '33170', '35694', '128059', '251417', '31392', '40181', '16530', '272624', '84670', '41692', '120363', '96194', '188004', '49417', '132476', '263889', '114006', '257277', '140293', '201005', '224370', '65939', '223926', '247318', '223431', '275603', '7156', '22880', '100232', '112223', '241629', '113491', '62438', '187775', '119348', '216097', '248837', '257247', '26808', '251826', '231025', '116461', '128949', '75938', '220200', '270628', '213207', '255852', '81371', '134298', '139032', '299754', '255226', '194299', '238023', '306700', '74870', '226601', '189966', '56006', '172048', '267092', '46615', '284673', '68828', '201980', '288766', '236306', '118371', '75892', '225770', '236696', '102408', '219350', '301321', '301320', '80627', '197778', '80620', '233356', '240915', '69707', '125868', '205268', '11650', '188343', '61557', '207867', '17769', '37459', '31197', '272375', '213327', '181978', '208592', '111734', '227173', '261326', '211611', '188815', '224622', '215343', '181504', '245322', '66505', '267799', '42946', '23656', '128763', '221274', '35934', '72385', '92496', '49903', '110766', '110543', '221740', '113369', '193924', '56276', '59712', '193921', '229903', '96099', '136234', '43342', '49358', '244623', '244817', '121584', '84176', '187566', '89266', '121427', '273250', '88791', '70280', '88792', '33436', '100178', '88797', '206148', '33439', '198112', '105906', '22798', '224631', '265959', '112169', '30162', '233389', '223338', '123986', '111881', '265811', '223333', '107182', '210618', '25271', '125676', '43469', '229090', '33312', '255343', '237009', '224325', '19664', '243646', '101787', '233171', '273531', '26690', '46495', '56989', '46497', '49073', '273539', '132570', '76124', '17874', '179797', '24202', '103114', '206051', '124190', '251646', '75441', '81615', '28006', '256174', '154449', '271598', '129728', '83310', '96642', '136211', '106941', '29920', '270439', '288714', '81668', '31544', '122602', '45175', '274073', '60405', '116202', '131650', '118573', '57295', '225343', '106973', '108146', '206606', '50453', '210098', '90396', '102534', '21844', '66623', '204792', '30858', '38154', '128600', '125344', '204378', '274219', '259470', '206585', '21285', '212532', '130366', '248024', '10397', '110690', '193322', '107551', '245582', '191616', '102389', '58096', '197232', '110983', '21735', '228561', '225768', '22335', '292277', '224263', '274917', '210240', '245207', '27863', '223377', '257534', '70420', '257531', '25640', '201582', '238889', '136205', '282560', '130448', '101708', '114016', '262165', '22689', '40247', '271366', '260011', '82666', '18938', '90172', '210433', '279373', '244829', '290088', '190740', '44780', '202826', '206179', '222510', '109524', '75393', '131871', '251839', '88077', '48724', '21137', '230252', '97076', '219460', '61277', '244180', '96179', '112433', '102168', '69234', '98562', '52068', '96700', '178163', '208299', '263444', '121358', '298736', '275248', '215259', '100961', '97289', '208416', '258654', '283495', '219605', '219600', '245926', '128258', '116481', '341763', '236442', '22373', '63956', '125708', '238645', '63951', '94481', '34640', '45186', '45184', '228925', '262341', '24196', '31474', '262226', '34984', '107456', '101880', '93821', '190599', '273314', '93828', '243338', '84140', '95205', '101513', '92521', '89787', '105553', '79203', '23289', '224472', '209354', '108793', '53766', '199215', '252912', '112903', '112674', '245243', '122842', '58795', '58097', '69870', '22649', '112425', '239180', '125895', '295793', '190743', '267466', '80566', '274185', '247108', '107585', '100499', '22360', '50103', '207958', '261900', '102213', '261902', '63841', '59673', '22785', '33272', '30171', '186643', '80914', '219775', '239235', '278474', '27857', '80855', '231412', '238039', '70299', '323217', '227426', '101635', '43456', '200941', '188825', '282586', '73447', '61531', '221137', '15837', '176266', '24602', '73449', '206049', '19850', '188122', '56853', '71736', '46618', '28182', '109909', '255408', '40266', '180923', '216831', '110203', '74101', '244261', '130149', '19915', '73360', '87163', '87161', '220809', '114624', '290546', '96350', '24351', '266861', '94525', '290062', '208148', '46604', '183364', '231453', '10223', '252998', '243981', '104739', '79644', '89184', '110754', '116213', '21638', '266396', '36098', '89747', '192978', '210555', '102424', '24508', '106514', '24504', '50444', '79934', '255224', '24814', '213619', '125730', '222247', '259260', '370050']
standard_valid_fold=['46663', '37117', '218708', '140315', '32459', '267255', '267252', '23343', '113162', '45860', '241164', '341983', '273032', '341382', '83859', '12812', '101851', '268836', '209758', '8404', '247538', '206507', '105963', '280951', '95887', '172044', '84772', '222605', '34684', '184784', '90986', '122581', '90667', '283935', '26110', '41032', '291121', '78398', '211875', '120342', '97992', '136215', '266938', '247764', '88881', '114419', '130456', '250430', '88888', '127908', '222116', '210238', '298459', '110824', '69824', '273171', '255338', '84924', '112631', '218912', '96361', '244836', '275620', '179875', '44457', '195575', '94215', '215318', '266791', '58151', '97095', '91166', '367506', '225416', '367576', '207964', '55156', '10219', '112509', '216007', '256935', '137920', '186631', '208465', '234406', '270956', '203806', '255205', '40260', '71459', '30763', '30762', '272817', '111104', '76104', '126542', '36164', '234587', '91292', '256976']
standard_test_fold=['102858', '277991', '118354', '79935', '219614', '114845', '180971', '302220', '191941', '49029', '57231', '236021', '98155', '238858', '226602', '125845', '140317', '252097', '130633', '89835', '111363', '121128', '233880', '32681', '60037', '238567', '294178', '207812', '254427', '60428', '84133', '206621', '38374', '266852', '257771', '50479', '219310', '245497', '327282', '92533', '59302', '267354', '91844', '129733', '167521', '193514', '298774', '22277', '241638', '188062', '45676', '65068', '127539', '110565', '236399', '29044', '267694', '121400', '52839', '280584', '271594', '201497', '229967', '136196', '21696', '92331', '220134', '36116', '273237', '127622', '83400', '27798', '535523', '234053', '241124', '35684', '7155', '80866', '267278', '196665', '74184', '98442', '81563', '48019', '172060', '47939', '239242', '96337', '234641', '270993', '69268', '252919', '38019', '227416', '99501', '43444', '95147', '253709', '268258', '93119', '221104', '96694', '41026', '136416', '243056', '40129', '93116', '51224', '78577', '110788', '133201', '209869', '30646', '273510', '224869', '47472', '74447', '368460', '131936', '94532', '199227', '70710', '221153', '226640', '227556', '94439', '260199', '88119', '115134', '264446', '40970', '92221', '268536', '112029', '216030', '93839', '99331', '217395', '224817', '100446', '10124', '52160', '104741', '24157', '248400', '83119', '134252', '224648', '224649', '370404', '92578', '258672', '207118', '135658', '280794', '34346', '110794', '50302', '50307', '50306', '261267', '79925', '26113', '238624', '26115', '125726', '202810', '126505', '116219', '81707', '46503', '258802', '105507', '22344', '207977', '112148', '229808', '93807', '87400', '137455', '172050', '224498', '294226', '121117', '22821', '282985', '91574', '132028', '103311', '59333', '206376', '118583', '91996', '28191', '79858', '53742', '270416', '204519', '95388', '50478', '257045', '91276', '29771']
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/dataset/standard_datasets/POM/pom_std_folds.py |
from mmsdk.mmdatasdk.dataset.standard_datasets.POM import pom_std_folds as standard_folds
from mmsdk.mmdatasdk.dataset.standard_datasets.POM.pom import raw, highlevel, labels
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/dataset/standard_datasets/POM/__init__.py |
raw={}
raw["words"]='http://immortal.multicomp.cs.cmu.edu/POM/language/POM_TimestampedWords.csd'
raw["phonemes"]='http://immortal.multicomp.cs.cmu.edu/POM/language/POM_TimestampedPhones.csd'
highlevel={}
highlevel["glove_vectors"]='http://immortal.multicomp.cs.cmu.edu/POM/language/POM_TimestampedWordVectors.csd'
highlevel["FACET 4.2"]='http://immortal.multicomp.cs.cmu.edu/POM/visual/POM_Facet_42.csd'
highlevel["OpenFace"]='http://immortal.multicomp.cs.cmu.edu/POM/visual/POM_OpenFace2.csd'
highlevel["COVAREP"]='http://immortal.multicomp.cs.cmu.edu/POM/acoustic/POM_COVAREP.csd'
labels={}
labels["labels"]="http://immortal.multicomp.cs.cmu.edu/POM/labels/POM_Labels.csd"
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/dataset/standard_datasets/POM/pom.py |
highlevel={}
highlevel["SOCIAL_IQ_COVAREP"]="http://immortal.multicomp.cs.cmu.edu/Social-IQ/acoustic/SOCIAL_IQ_COVAREP.csd"
highlevel["SOCIAL-IQ_QA_BERT_LASTLAYER_BINARY_CHOICE"]="http://immortal.multicomp.cs.cmu.edu/Social-IQ/qa/SOCIAL-IQ_QA_BERT_LASTLAYER_BINARY_CHOICE.csd"
highlevel["SOCIAL-IQ_QA_BERT_MULTIPLE_CHOICE"]="http://immortal.multicomp.cs.cmu.edu/Social-IQ/qa/SOCIAL-IQ_QA_BERT_MULTIPLE_CHOICE.csd"
highlevel["SOCIAL_IQ_TRANSCRIPT_RAW_CHUNKS_BERT"]="http://immortal.multicomp.cs.cmu.edu/Social-IQ/transcript/SOCIAL_IQ_TRANSCRIPT_RAW_CHUNKS_BERT.csd"
highlevel["SOCIAL_IQ_DENSENET161_1FPS"]="http://immortal.multicomp.cs.cmu.edu/Social-IQ/vision/SOCIAL_IQ_DENSENET161_1FPS.csd"
highlevel["SOCIAL_IQ_VGG_1FPS"]="http://immortal.multicomp.cs.cmu.edu/Social-IQ/vision/SOCIAL_IQ_VGG_1FPS.csd"
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/dataset/standard_datasets/SocialIQ/socialiq.py |
from mmsdk.mmdatasdk.dataset.standard_datasets.SocialIQ import socialiq_std_folds as standard_folds
from mmsdk.mmdatasdk.dataset.standard_datasets.SocialIQ.socialiq import highlevel
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/dataset/standard_datasets/SocialIQ/__init__.py |
standard_train_fold=['W_GrHtwZez8','3wIejfT9l30','gcDnKQul_c8','qr69jLeQdRA','lo0R1mvjDT8','vKkpvQlHEG8','B6p6X1LSjiA','8m_3eBsy22Y','gfA1xa-BMCg','EqXKrS3gPN4','LTUojzYVUUI','FJF56lmDqQo','QC_4iR0tyvE','E0TBOKN8J2E','g67e0hDT1oQ','s3Czwcz3E-o','D56yCIgqqgk','QQpIBRLlJzo','4pYqIEQow2s','72ltfGTYqpQ','ofvOXABptcY','YlVkBzXo0YM','4VA4kqMnEqA','OWsT2rkqCk8','YIZpD3fEfgs','qh8JWHlIgcE','DW2umNQrQU0','vC63_bemI2I','g8cyMIFcC_g','n6-ef_YHeJU','vqFmKLl2hq4','k5bk1efKBSI','xpXCQkb4LUI','4yr_etbfZtQ','zYeBxnAm2wI','JW2HHfQiGVs','o6DEc3OYQfU','SJSmbF9W9PQ','gKuBUQVcDJM','P8YRuxu8dQU','KBj3TocgvOA','FWBCTZiijEM','lC8nM75AqUk','dU7L1hvMx9Y','Q25kn317a2M','_tBXwqueWcg','ipnGPeRIy2k','97AUfvzQ_1E','WVnNoiQKhPc','pc3__b1uF4Q','ooUw7Hq8YLg','uivjORoSW0k','G3xzem7HSME','CoMz3JOnZFo','cGU1Pepn1hU','yRtPan09Ek0','mNcdlLIOdNw','3udl28R3yIA','-99aZZhUgRk','RgGLnaS7smE','nzj7Wg4DAbs','0SuGC2ifkIA','Iu6_k2ok00U','zzWaf1z9kgk','T1icdxz0TNs','pZCz9-b5Grs','kIfsmKj42XE','EC77tcJZIdU','ixQbCXLUUj8','kYnmc_AVfMs','QtANwxed36M','xWjiz7ZrHkA','bBRWF0wju-c','kmgsC68hIL8','e6ppqFNBkLo','AiIrjf-s128','eKQKEi2-0Ws','FkLblGfWAvY','DClIawJYpHs','lcmI9_aypI0','zT-1nFMmt9Q','kGoON1J872w','C2PneBztZ3g','-QQ0Lv4_--4','1akNUksCpRU','XZn3wQhEXWQ','QQKG6cd-sBI','58DqoE56OWc','xwQBg9pVxrQ','UwPd_D3y3Pk','QUd09jZIQEk','DiaDblUd-lw','jvpj4qdPRE0','QHeNKMxsqYE','XE4ifwZqvEs','tfVvLs379Oo','h9hAaQOanZY','A6Pz9V6LzcU','-nO3dBeh5n0','a80o4DGxt7Q','QqWrqHC8wjs','Bg_tJvCA8zw','4oh_PsdY-W0','GGEXxniRfWQ','VIVkYG31Oas','mJwWxbSR6r0','PnqJALSs6so','vLS1o1F6KqE','_LUX70mXcEE','WLBB9CqfMCk','6qNawyzVGbc','4An2AF2rWGk','hjGsGtihBpc','-VNNzqqnaew','7GRWqlKfgmg','L9U9hvUf42g','EWUfDU8TWn4','B5ltukfhtw8','B2V9PFGQBH4','B-gHVjv4_c4','i3itBKdwE7M','nEpJaJyeRy8','DelU5tQ4grw','Va54WZgPTdY','hkAFdIrTR00','ZeYarFkvoGw','9eqze5JWNjY','h7YTPuEMgaE','G4heS2754l4','8Kv4F0D210A','Bd_vAawM9LA','Cv4Xj4fIkRo','-daGjyKKNio','ON45DvDMSk4','T8JwNZBJ_wI','4W192A7g5KY','nCQB2AaVgOY','spdhjKK6zCo','shL1gWm9qdg','D1Cil5n_-zs','hKfNp8NU82o','9cFEh0aaOOo','eS9U1QO0F7M','Z_FMSWtuU6A','YnqZfVCUSiA','7bc_qfRmPK0','-8GAQpsV4Qo','cq1er8IWz1U','wDgVPV_t0AE','cXTjL-f-msU','lTk5zkc0i8M','Wo1RxRjXyYw','NFKdaj1Qsek','o4CKGkaTn-A','i5YckMkwmm4','ilotZqzaZgU','kztkcj-WAvw','IXbAYg5pp9M','qRM1D4jE09w','2XFVnzr4Vho','gjX78p5tvfo','lKPRa_4hnlE','nblf7Yw4jys','eDqEcrIRxgQ','11BN2alqrFU','uk0Ntd8lJ98','B7Nbbxh3m1Q','caOaW604Tqc','Ilf38Achvzk','LmCJIBsQjOY','X9BE2oUSOXM','HSEi0RXGVq8','tv-hgegVq0k','mN1Z5xEOy10','ykTHGJLCstU','WczPTuyEt5c','HFPGeaEPy9o','2ZkzLAQszHA','tvcrwTcA5iw','HCgv_HNoJrY','SBp5KuQC_lA','0a2lv4IwZFY','br0mu7r-ak0','4HHR_3HJdEQ','uJUP839M2WM','vsNVU7y6dUE','nqY3tv-y62A','GHBKZZuA314','sqDIGuzt38w','EeClqsYITso','HzH0cBmHg5k','lmcuesVvLf0','ZoInHw_M_H4','9QdaNUrq1EQ','5_uSZcXMV7s','t-dmFuH7TyM','hd8bXHCvZME','jiMUoVjQ5uI','Qf2fBuiddNI','qDpGgd4oTQ8','YVHJpAROBvQ','YZR6LEk3doM','_Ice5RkbWUY','DXyaQVlRVkY','fZuk-TaECZo','Xs1sMqpc1oM','1GJqfyzfCWU','2a01Rg2g2Z8','KoH4OKx4x1Y','wRMF9hqdcTI','CggDN9EIuNY','F0wIBTfLnE8','AHXwnFvqYDk','1A7dqFxx8wU','jrv2BW_c8jA','Nra5F1tQQww','-2NF882DbaM','47U9SVOiw4o','VNM7Z7hir_I','x9lr8OomuJ4','SzCgZK1KMio','ecALuiFDRT0','XwUcQU9BFDI','WR0hwJp9AOA','8-Hi9NmF4rM','2c_nei61mQQ','PR0y7IlMEOs','zVrWAxxLuA0','PR04klFMPYQ','yDDRstyk9Dg','XjAmvLVbE3E','0B9VJfzqwhM','DWmUHNpOJxI','p6CRBNmX_gY','R4QbJL80Ri4','HMkOO15nye8','qzCjToACNrU','qXG69NfiePE','zWaV_PTlCxk','ZVR5lhbmGw0','MdG9Lkk8VWo','pK1WAx4jJzE','sQ3pkACdX84','uH5JkfBKD9M','Jp_KHLvQcuw','_s42gOg2WSU','3EwNcTzx-Bs','-sp3Q524oO4','C08WmKiwcSs','bMuoPr5-Yt4','9qK9VQDELpc','bb08nFwfoxA','ap9vRY_Vdwc','rB6WmWvvyxg','Eg307HcpbJE','APshm-9gPgI','Tfw2mq2wJls','4AmVjblOvy4','fpxPstb2DAU','02A2a-aEvmI','i7JGn06gsnA','rq-7zoXQ69Y','RFcuAhpQdXU','dONZkRDs4k4','PjBxYw4SJVg','YTwEFUfX4zA','gbVOyKifrAo','MlteErDn4to','DB7de4nC2rc','5NHofFOpsDU','KHgGasfOFPg','US7hym404bQ','o6hMDs4rBmw','GzPIbX1pzDg','5BLjOCK2SlM','AQ7wbfX_av0','6rkV4QRcVnk','OMkfujDPpwc','badtXoOJaf8','nLu13aVrNcQ','GCZ5aagOddY','JNGcJEZ6rwA','R-xtt7w9Do4','3yovMKR__4Q','n5V7TVYiVas','xNxw4rbwh68','mxa4KXSz9rw','xs8O-MFu4yU','rVWZuXDkc4A','_T3uHSwRgdU','31ktAMJocw8','a6Ke1YThz4o','iFgOoTRflnw','SrMN3rwvCsE','8_Av3cDcoR8','SxtSW5HFkvg','nmWplIQhvoA','fC_Z5HlK9Pw','AciwXaRfh3k','Z86hdiW6l6c','3nUKwvFsjA4','kf9RtsXQPWU','MM0YOB-cSWA','tXG-qPZJj-8','O24d_rJ4uDo','tafBLziHJ0g','hL2u93brqiA','s_y9h4hK2PM','2NE4KCCfutk','P3QEOJWxXI8','QoIsjc4-GIg','H-q0zh-XGVc','MsjnLoTKAXo','ajFmgmUSYAc','teg6qTE9Hjs','B1VB7vVQNQg','ngHnomR-114','N4fvzhsdTio','1j1C3dlwh7E','LcHtLypALog','KB_p2QvvLGw','ukn4Yw4mB1Y','TyFWoohX0bo','luJceOt47UM','3xdQIW24aj0','zHqGiZQTxfw','U4r9ePA6RkQ','2GRzO0p9uVU','Vlh0sMMjU04','zXbortaLKDE','N3QuD26DuCI','b9aeM__20E8','kRh1zXFKC_o','k-kyKv_kKGU','nQqY3j8btbI','XHBZkek8OSU','Bks4JX95dD8','3_-Bjqs6AxA','RZPBl5-cu3c','fhqu7ve9MA4','U_JrsRlieNQ','XYBx__4iAUw','A3WbCRfad-w','xWRNBOXoLf8','iovKlisBCzU','SAgYiERRDPY','DK8s_btC8F8','1CjUHNYzW1E','cOlibbx5sx0','4vPrTC5qMh0','bCWEOlvi5fY','vjZDdaFTubE','h-H1LddWxo8','Y7eYfHIyn3M','sheEL099ADM','L3uDQ0S1Iis','IsgFVkMnqJc','3qp3AeWmt38','7doQf8xjFVg','8y-N6UDxTxQ','d43n4njmxcE','Yzq6fNeXf6w','AZCs9VoHeBo','PsOnuG1EBjQ','n_mTiDeQvWg','RZzaa_PqNJI','29rvfxBQBQA','D0a2KWuL4S0','D1FXpqUivtU','_tYPnaK5gkI','0B7UgDEzcUM','64mWOoj68qo','gAPPzmRb4r0','XYviM5xevC8','yDrkv0iVtsk','Q5YJ7mh8zWc','Zx7c8huezqY','IlLFTI24Qkw','6W77wcXg2no','fHW461eiQp8','9l2W_GDiNyE','HwIRCeUCyxw','XFP-qBKzDBY','ElghrCC2Rbs','tmkqp3VpDCE','jYSuKn09_e4','_oqc_t0mbsQ','n5_HdNzf03Q','FybhAns3or8','8i0Vr6DiBCQ','rZLwPui5TQk','utkUkvYq-zM','GMidefrr1MM','bLVm1vfXRw8','2Wk9JY6ic0k','5RS1CKa3JVg','oY6BfHkNFPY','0_8zVtd5VLY','rnbtRiLamsw','_KE_-EdMhDI','1B_swZA4Hqk','oW3UPfXHSUs','mVnqP-vLpuo','FiLWlqVE9Fg','hRkl5WhbQLc','grTg3dzQDZI','YNmgvI44N5Q','OLw7cIJApMI','3m-54UiEqzg','HN75tPziZAo','jYL4gMsGZgE','2SIhhPzrjVA','hcu4zY2HUQY','2MrFWB__GIA','QRRzvOvG21E','UzzPYlIeSvo','AKAtC7easns','muuW2EU8nrA','0djStqAuc_E','vlnKSMw5v1o','VOHCh8U9XQY','9PJb4cFWOfY','ullXTZ0jjZw','RsqRaVYQ6Cc','DZsBei4nCkU','_xChA_vIuxE','XKyumlBmix8','bT_DEZz99VQ','I0izJOlMJiM','3eCZ8haia58','b0yONlMjxjs','QytntXWJIe8','_0at8kXKWSw','ogIbkhMeJFI','rFJIgAmT8dE','F2Xul-ihUVc','L49M8C4wjVU','srWtQnseRyE','fDe50VbOU44','ZuBzOV1ADkk','deKPBy_uLkg','p9GrpGa8Uys','8SGQ0VdXvAg','tbwPN9fZb2Q','eTnuG394AcY','pXvVnvQOMQ0','STbJ8hJFMAg','4_BudcPRi7E','N188QSyfmeQ','ZKTIOHRjlHM','4HxgOizA2Ow','NZtIGzAzJZM','4iw1jTY-X3A','COYJC6dvB8I','c2pwnHLaYTQ','Kjlt_FgKPgA','-ZOjNsOHtOU','47lUTksozNI','g8D-LyfTrRs','hezHSFSwa08','WQxM_EK5aiM','56EbHWYK_q0','UUuXfyfCaL4','UCW_UH-k-ec','jfKDozXX_Uo','fz0q7YKjp48','LtxWWUBt7ro','GI8LoYEYKI0','oxZYBldwpP4','cuR-l2qCxBc','hnfkZx4jmpA','Me-A3eOhgXs','8xFtIsyRvNE','ory7fcHYXhQ','8fN6D1VOHlo','QFTvmsHgFYM','LBd5x_fe4Jc','x6YzIqb6Cas','8Rk4sGEBJlM','aRQLU3IwNYs','V-qtKSEGAac','2jMvc5VoavE','nGah7qST1dI','q45sJ2n2XPg','1a4Gx6UHdI8','aS01LwpC23g','g7OMgsD7T74','y1Y02_oZP8U','8MK9frCMoWA','2gy8H-wYzic','LTEiibVnRgI','BEOdicifuqM','CY2D1L1JtKU','KWS6OcNbvLA','6V0UfejAo_E','WV1ncOsZjog','_UJNNySGM6Q','aNOuoSVlunM','VP4rHzYyuL0','ZP8ACbJ677I','Sir2QeCh4B0','-jDIwv4wCsU','RJnquSNVuuw','NR9v3PBJw8g','EGK2P1cOJJc','GK4_G33fXFU','RtjJBtFXJaI','wZoXjg1x4Yg','Cn_Mlwouwng','lacVKwbsE7Q','kzhJb5jcH58','f-BbAnnQVtY','TDxlMelzl10','CwanEycyH_8','rmZGPAXE0oA','NysITFb_Wbs','0hCihQ5Kep0','_zuODgCQ6O8','No6mB6V1wL4','yK1RQv3S8KE','sGAj25JPwcg','x6yr8W3mc38','66ojfophGys','9m0d0RaWpfY','zqgqVF6lWB0','F2mIH0vlI9c','ncHMwblapdI','fmuEMg2fh_8','AQX2Q-V2Uh8','LchHXKL6xZY','Mek_AQ5DbUs','8NL5jXoa-Jc','EJdboFptQ3o','6kYu7-5EyU8','jE1tmy-g6tw','s5ak_9z3Cp8','b3I1tK1Iyzc','e4mvg9r6_cI','f3Ch2aIlXWo','s5jrdHASx04','L75hdqt98nw','q0r-dKImVLk','17PtS1Qx8kU','sjzVFt59eds','jP2HuCwfKFA','Fy6BOTB4sXw','urYGhhMOToU','uB3FdWmnFZU','VeV7vvfipA0','4wdeBJ39Cuw','YsBSR_z9BR8','6I7Ktp4dV_s','6AzXxhPKh8U','VsSGubvfPiA','jdrVAQrzt9Y','UJLb8PfQYl8','SsuLW2JpjEA','jKguXsNkJ4w','SQ8aRKG9660','D2VcClclMbs','vTLkSpY_aYg','hBdsfj0YPO8','ASqnnZpsX1M','-0REX0yx4QA','nyqh7vhU3X0','0DBfvvIVmqY','EUIIWsgDpZY','25Qq8k7V83g','jbHKeVsI35M','HDhwReMUBsA','ziwYbVx_-qg','uXlJ3ezSZpg','C6RMS4F6LDc','1iH8ajlHJ1M','BDEUrfqlwcg','BiV9eJU8Gsw','VPTjROKYhlU','jK08J1811uA','kOIWYXDRR7s','WSqbeVe4jXo','afXewnGZXKs','YgfaKTH9RbY','yIhH-_BXPr8','3zjz6ryPvIg','FgnO3muvvoM','WhsZxUWSHaQ','S63inYNCsCM','LD1RAPiT_7A','XFGAQrEUaeU','xdiFzcpmmJc','09j-Mg5guGg','wA4i3eHKsTQ','lB0mkAa1vfM','N-6zVmVuTs0','IsEykad2V9U','IE6r8Pk91T0','U-Y_HkD_0O4','atEkAkPfpUY','mPAESQEQoms','IHU9Jc_NUuk','3d--LpVQxDo','xITR-FIi_oA','ZYzql-Y1sP4','VxS7HHz0mRI','5slZuaphzVs','aai7dDBNXBs','OTdFPlXfFj4','7Oum_c5Seis','o92pxWhZomM','lickge5rPdc','c67D5bP0Hg4','Wg7ppxAgcuw','gImYPbTTZko','KCbXRRvnFj8','w_WAB7TXtXQ','xaQYLAM1LHE','abOuBvUfQk4','-bSM6iswghE','PQW7zw2URes','wz3nVBPVgIA','1YOzwKKbuPo','2YGrrsKs-Xg','xWLmbDdg9tY','Z7MknXjNJSg','O_xHNbx5jqI','VTPz9z7M6B8','2G-B5upjLjM','tVvGairu3Hs','sqIR2N5izHo','Ob3hr2H3VD4','qe--y0apjcU','Nck6BZga7TQ','gDVmHsYgJUA','hRcSU9-krNU','MBDZbACupsc','96YOZOU7ggo','Hv0PyGfxbpw','iwCdv9iR8P8','aDJJBMXiwiI','Obde542xA9I','ON0rtQyNS20','gBs-CkxGXy8','bCKOVlsSluU','G7bkiEh7_AM','zzERcgFrTrA','SjrMprYa608','E4MUXs4IHtY','Y6fVeuHTx0w','awpHn196aVs','NcHQjL_WlxQ','TCCYCSACA2Y','ktdgC1dJkOA','vSQvk9P1dus','kVh1Jw2D9NY','B7XIUxyTi_8','7grGUUPbEbo','lJ83ILGA8yI','0LDAgvbRtk4','rnj_bAv7Hyo','j7cUdCFEpeU','hqzF4IDaIYE','QCR7uyowjhM','0aNFS1cLs4k','dACF-Mz-X8M','Op2e8_JURSQ','N1fVL4AQEW8','dvisqlHIKpM','cHpER0dG1o8','RAUSVB_Nu9k','d89i7OY2yTw','wbmW_Z1oPJw','BC0dD13bwEw','r7rpWLLPQSA','M4blAdS6r3Q','Xbx0Dl90wO0','kmi_liqBsdU','b1OedrPQ464','qow_n-oNEt8','5OUcvUDMMWE','nAkqWGO1T-c','YuU1QV7N9yo','W-V0sdbQA-M','oYM9bFGb8B8','AHiA9hohKr8','kU6YY2z7z0I','fce2RtEvPr8','E2IdU5lgaH4','dVJAvMbb8H4','ZuYTtKZUkJc','epy3Dy2FUOI','-9NhaKWMtWU','4Ry2bE-WRqA','vE0R-Gw_GEA','9jRkACywckE','tNami65DCyE','LiqyOoGW-I8','sty54JE9DHw','A4gVxvYFA3M','gDUFvLWl-Oc','ApExci9PnNM','MIFz86h5nEA','tth90qiKXgY','h35dZhHkuFM','j1CTHVQ8Z3k','ucYhn366lts','ICBNX0i855Q','noHN3H3gWPQ','F2YbeTjcpfs','MHVrwCEWLPI','D2g3gTRkv0U','6xQv6ozrz90','iOdEJMNEzyI','KaIzZrMb2og','DE5S7W8ZfnI','PVD-SzVd_UQ','43fC9xuQRCY','ndsKiHu63oM','cwoR3fkcJ9g','Yz4NWtsQm1w','Nqf15ViHSmQ','5fy7S3jCyAg','ggLOXOiq7WE','T3cwJlY8OYk','1YFLBjR-swo','cQREa5Y-jqk','wYLmgQy6zq8','licUm-aEaCY','l1jW3OMXUzs','yMC03qoBlE0','OT3MVRv0TT4','EwAb8ZW5Eiw','iDgaqD7CWXU','Fy3Mi8rOB3U','0gcuigYJ2cw','2ihOXaU0I8o','m075kb3aV04','VopLr9b_IgM','erOpqmubBL4','KWSDwS4S6Ss','gf5mfpSDFKM','pMGhqE76kQA','TpH0DD3MCUQ','ifxLhziWjm0','LoMhBo8ATBM','7_lpdZhf28E','K25zmgYg5s4','1Za8BtLgKv8','oRBPxefAHTY','PR2fDvbCoAU','DpTB4TDKIa0','YI5l5ltMl8g','zoE6RKgvBlI','13tG38-Ojn4','lUyKpfbB9M8','lkeVfgI0eEk','mr88Ud5V9uE','e6zn4UlO0fU','ztlOyCk5pcg','29vnZjb39u0','N7K5DQvMWXM','bwzH7ceQX8Y','uNU6H62jNxA','90P3VEbzUK0','2DTwXdqmRiM','aXiMaioTUkg','KpljzfIVBDM','fV1o_g6uzuI','A48AJ_5nWsc','1mHjMNZZvFo','MDQTH8WkAvQ','OFia3dWgaoI','xpIFaKnNvco','p6IwwFevo7o','dI5D3aTgjZk','3esHlM0cBx4','X0jMZoxUL2A','cGTFuTIgc88','_AuZO31q62g','ZfZhi8nnnLI','8w41NfRyWqE','nZiIVvEJ8m0','HPszYa77CkM','iBL0FcUTFT8','ALbnaCezgdM','kefqa4xre2I','KBMAUGQpHBU','Nx5VK6DUUEY','FAaWqJLCCd0','O8iOYngEUBU','_Z1tcdf6qkI','WXuRTQPKwqY','NgPP6UXVkYU','q53HUAKB9oU','7FYHA728nBI','qQPl5ySv3Fk','xbhXd8lj2s0','onbBEbC24SQ','sZ9gSPUdZIA','o7Ax6SRTGks','YAYfMkxhRiQ','4HN0caXjW3s','Ot1aZoxt9PU','3eaASCCJB4U','bJ-G8xiLB6o','sJR9QjezRGg','QR43TImr0dQ','YIJ0mZYi1O4','Ham3IQQzoU8','6dCClwMqJK8','13HM_96pUIo','WBOT0Tqpbag','jMZLrPxp31E','dZPwXsbohK4','fL3_AauvjJ4','I4mItsGR3uI','Q3PJuGz0Njs','4tLBy9FGS5A','qhlmvp3VDzI','rMRWJEvKopk','Vwn_QS9vB1g','KvbeKlGeNRU','waE2GdoBW68','UUukBV82P9A','VX671ftXpMU','iiDdvLrSUG4','5WgFDQUjg5s','2K09qUoN1Oo','9L1tM3fOb80','GcImUUGmZ3I','9hn6Z1o-IYI','4KAvDyGzz4E','ajVTImleJlk','alg7qHta0Sk','TewPhK6CZ-Q','4_jXi0nzuow','BH8FUBW4IIE','xXIq7YPkdUQ','-RpZEe4w4fY','MqiOBIxouw4','87yBSfgwoUI','Ate-1815RNA','7wLDCFduiLY','qN-ZCqaSHHk','34XCuNsQ7O8','eS8SpCRASr0','3vjA8sDxDuQ','P5ZOwNK6n9U','ujj3zYdBd0k','Mf76yyTY7Ss','QHGeDg6XX6U','ytEgqN-BdKA','8TDAP0KNIIw','yq1cX1lAyQg','im_uLJKzs-4','iNr9xdc6cVA','pFUXcA1fp6g','ZMJw752P7z8','PfwwCpAy0-0','8ACAI_Z7aLM','imUigBNF-TE','79I7_vkwaeg','OPdbdjctx2I','KzN6XWDEmXI','b-FX9NOVQOM','J94uO-urSTg','Vbp7qtUXQFA','I7GvG0WYfOo','1IHDvzYwqgE','T6x-kDiQsWM','JxbV5wGpXc8','C0g5RjQ7cRE','P3UP62l7g6Q','NTpj7quCIqQ','ctHj7R35dL0','SWNXZbasPvQ','RHRPK2O9R4w','PIqmZBVVH0c','TA3Xy53hMMY','zf2tZ0HIiPQ','T86T9wMn77s','HEke6Dlhqtw','EEDZjwA1wM8','CXmRmrBPDII','jtl5XK7QP38','e8v9i_ksUyY','t4-ZulW5np4','mO8TK-QaIf8','NmWjnYUkT_s']
standard_valid_fold=['PiYhxJzWLzo','ZyIQkgixS_o','4Vic0qKl64Y','4EZxURAhU6U','yKGfDlxvR_Y','K-bZQJ3P9N0','SstGaYWCNoQ','B6PpxrnttDg','H0Qdz8bSkv0','44MVdpDEQJs','G1wsCworwWk','40mpZRU47T4','3uk6rKXbG1M','5XEQ8rYl1qs','LcMBahfo0NA','pawEXwLjTlo','_yHLgEDXZbI','mA402F5K47o','n8Cn_KhcR7o','MCAH-zHLTLE','NnhpG0nEC84','G4ROcoq32rQ','aSZ_eLxuLAs','ahcAFnY6iAY','bgczomH1kLk','n71IBjXHnrQ','Md4QnipNYqM','00m9ssEAnU4','WI9QnhX7vcI','ks66e-O4YCQ','Csy2RxzkbaM','K6v2QYiMdCE','aw-fKJhcQE4','jh5PklItWjA','8wLCmDtCDAM','u_pE5O64Q9I','6b1QbKtmaZ0','-DTqvzmUw74','egw67gXKK3A','GeZIBgX7vkg','P2rLv-vjSOs','kpMLnFxvi6Y','DuXGDE6tolY','ACPPfJtYCVc','wB_hjqZQ1UY','t7qDtNdJAlk','2nDh8MQuS-Y','uANIooMR9a0','a0tn33wZGVo','F4rSKCXqEw0','xQwrPjLUwmo','igH3ixpts2g','7GRTyxc4uMU','4LGe265pwvU','izCiPuiGe9E','PFA-RmV_wG0','BUumpYIgVg4','j5SKmUoL9Tg','sPxoGNvnVzg','j3pLDghHKyc','IbkyL0pDtEc','CNHBsxOZd80','3oj7mCSydoM','1MwN5nDajWs','G22mJGndp14','460_-P8pK8E','JMzilFvwNXE','tjogri9eYzs','NTySVAtrdQc','iEENyD0JiRE','CbMVjQV9b40','5h-SslT--8E','FaLaPEnjeqY','lTfsqoo-jKg','YRmjALBdTdE','OsQdzsIMFPQ','mpHoYhIFKNI','nRfU_c4QlaQ','KWnV1Aa6VQ8','O951zoCuU7Q','VPoNcAeOycw','S0xTq15pzJU','fsBzpr4k3rY','wf1LTMcVFEc','S8vC5FNRDTU','JRYjFh_hHBs','TTY4WKXoPac','ThpV4osXuCk','GxYimeaoea0','GbYGoWvJpwI','ocg0MbBfCS0','PCVvpS7w-2w','2hLcCnZzRtY','EaPaLCuXjT8','O5rTU5EA1C8','wu9D9hdwOQ8','-hnBHBN8p5A','Ddbyb8zVKG0','qAs7UWhTyaE','N5sGxcAJFCA','z6qavchy4Ho','2im0kvBEIrg','aqGNOsZFdBU','bC9hc4cqHGY','lpAMi2lwjo0','geaSpx-R4Kc','pG8zAQGgL1o','Am6NHDbj6XA','FositxHjuUk','TyR3GMJJVhA','dKxXtOyMmYc','hrhX40bQYY0','ihP926ccYDw','-Lp96hoSUC8','JW3OfSCZlhc','otna1VHHCow','eTph1-CG280','JXYyQamYw84','vVaZzurwxeI','RS5x5GW5bEE','vaHpVjqCnNE','T0jM37coZPo','6tAfdCTnToY','OqL_u-uGIi0','Wp0xufdpjqc','SADub7W22Zg','9kLNVTm3Z90']
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/dataset/standard_datasets/SocialIQ/socialiq_std_folds.py |
from mmsdk.mmdatasdk.dataset.standard_datasets.CMU_MOSI import cmu_mosi_std_folds as standard_folds
from mmsdk.mmdatasdk.dataset.standard_datasets.CMU_MOSI.cmu_mosi import raw,highlevel,labels
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/dataset/standard_datasets/CMU_MOSI/__init__.py |
standard_train_fold=['2iD-tVS8NPw', '8d-gEyoeBzc', 'Qr1Ca94K55A', 'Ci-AH39fi3Y', '8qrpnFRGt2A', 'Bfr499ggo-0', 'QN9ZIUWUXsY', '9T9Hf74oK10', '7JsX8y1ysxY', '1iG0909rllw', 'Oz06ZWiO20M', 'BioHAh1qJAQ', '9c67fiY0wGQ', 'Iu2PFX3z_1s', 'Nzq88NnDkEk', 'Clx4VXItLTE', '9J25DZhivz8', 'Af8D0E4ZXaw', 'TvyZBvOMOTc', 'W8NXH0Djyww', '8OtFthrtaJM', '0h-zjBukYpk', 'Vj1wYRQjB-o', 'GWuJjcEuzt8', 'BI97DNYfe5I', 'PZ-lDQFboO8', '1DmNV9C1hbY', 'OQvJTdtJ2H4', 'I5y0__X72p0', '9qR7uwkblbs', 'G6GlGvlkxAQ', '6_0THN4chvY', 'Njd1F0vZSm4', 'BvYR0L6f2Ig', '03bSnISJMiM', 'Dg_0XKD0Mf4', '5W7Z1C_fDaE', 'VbQk4H8hgr0', 'G-xst2euQUc', 'MLal-t_vJPM', 'BXuRRbG0Ugk', 'LSi-o-IrDMs', 'Jkswaaud0hk', '2WGyTLYerpo', '6Egk_28TtTM', 'Sqr0AcuoNnk', 'POKffnXeBds', '73jzhE8R1TQ', 'OtBXNcAL_lE', 'HEsqda8_d0Q', 'VCslbP0mgZI', 'IumbAb8q2dM']
standard_valid_fold=['WKA5OygbEKI', 'c5xsKMxpXnc', 'atnd_PF-Lbs', 'bvLlb-M3UXU', 'bOL9jKpeJRs', '_dI--eQ6qVU', 'ZAIRrfG22O0', 'X3j2zQgwYgE', 'aiEXnCPZubE', 'ZUXBRvtny7o']
standard_test_fold=['tmZoasNr4rU', 'zhpQhgha_KU', 'lXPQBPVc5Cw', 'iiK8YX8oH1E', 'tStelxIAHjw', 'nzpVDcQ0ywM', 'etzxEpPuc6I', 'cW1FSBF59ik', 'd6hH302o4v8', 'k5Y_838nuGo', 'pLTX3ipuDJI', 'jUzDDGyPkXU', 'f_pcplsH_V0', 'yvsjCA6Y5Fc', 'nbWiPyCm4g0', 'rnaNMUZpvvg', 'wMbj6ajWbic', 'cM3Yna7AavY', 'yDtzw_Y-7RU', 'vyB00TXsimI', 'dq3Nf_lMPnE', 'phBUpBr1hSo', 'd3_k5Xpfmik', 'v0zCBqDeKcE', 'tIrG4oNLFzE', 'fvVhgmXxadc', 'ob23OKe5a9Q', 'cXypl4FnoZo', 'vvZ4IcEtiZc', 'f9O3YtZ2VfI', 'c7UH_rxdZv4']
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/dataset/standard_datasets/CMU_MOSI/cmu_mosi_std_folds.py |
raw={}
raw["words"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSI/language/CMU_MOSI_TimestampedWords.csd'
raw["phonemes"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSI/language/CMU_MOSI_TimestampedPhones.csd'
highlevel={}
highlevel["glove_vectors"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSI/language/CMU_MOSI_TimestampedWordVectors.csd'
highlevel["FACET_4.1"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSI/visual/CMU_MOSI_Visual_Facet_41.csd'
highlevel["FACET_4.2"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSI/visual/CMU_MOSI_Visual_Facet_42.csd'
highlevel["OpenSmile-emobase2010"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSI/acoustic/CMU_MOSI_OpenSmile_EB10.csd'
highlevel["OpenSMILE"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSI/acoustic/CMU_MOSI_openSMILE_IS09.csd'
highlevel["OpenFace_1"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSI/visual/CMU_MOSI_Visual_OpenFace_1.csd'
highlevel["OpenFace_2"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSI/visual/CMU_MOSI_Visual_OpenFace_2.csd'
highlevel["COVAREP"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSI/acoustic/CMU_MOSI_COVAREP.csd'
labels={}
labels["Opinion Segment Labels"]="http://immortal.multicomp.cs.cmu.edu/CMU-MOSI/labels/CMU_MOSI_Opinion_Labels.csd"
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/dataset/standard_datasets/CMU_MOSI/cmu_mosi.py |
raw={}
raw["words"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSEI/language/CMU_MOSEI_TimestampedWords.csd'
raw["phones"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSEI/language/CMU_MOSEI_TimestampedPhones.csd'
highlevel={}
highlevel["glove_vectors"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSEI/language/CMU_MOSEI_TimestampedWordVectors.csd'
highlevel["COVAREP"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSEI/acoustic/CMU_MOSEI_COVAREP.csd'
highlevel["OpenFace_2"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSEI/visual/CMU_MOSEI_VisualOpenFace2.csd'
#highlevel["OpenSMILE"]="http://immortal.multicomp.cs.cmu.edu/CMU-MOSEI/acoustic/CMU_MOSEI_openSMILE_IS09.csd"
highlevel["FACET 4.2"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSEI/visual/CMU_MOSEI_VisualFacet42.csd'
labels={}
labels["All Labels"]="http://immortal.multicomp.cs.cmu.edu/CMU-MOSEI/labels/CMU_MOSEI_Labels.csd"
extra={}
extra["glove_vectors_with_sp"]='http://immortal.multicomp.cs.cmu.edu/CMU-MOSEI/language/CMU_MOSEI_TimestampedGloveVectors_with_SP.csd'
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/dataset/standard_datasets/CMU_MOSEI/cmu_mosei.py |
from mmsdk.mmdatasdk.dataset.standard_datasets.CMU_MOSEI import cmu_mosei_std_folds as standard_folds
from mmsdk.mmdatasdk.dataset.standard_datasets.CMU_MOSEI.cmu_mosei import raw, highlevel, labels, extra
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/dataset/standard_datasets/CMU_MOSEI/__init__.py |
standard_train_fold=['hh04W3xXa5s', 'GdFP_p4eQX0', '4iG0ffmnCOw', '81406', 'qyJiDgtj6YE', 'KI2sU-mhM44', 'qXisb7w9LjM', 'CLkTjujFVKU', 'aMtFBGh2wKI', '2OLVF-KEaZU', 'Or-9Nc_GAq8', '72tXTrSXoMk', 'hSgKOKK3L8M', 'YVHJpAROBvQ', 'pVzHaakhKAw', '127470', 'wY8JbFOsp5E', '-iRBcNs9oI8', 'sLaTZtL0ZIk', 'txjqbr6FoZs', 'jVayR0VClxQ', 'gZF-YNQHqwI', '214095', 'Z3fcd1wdzr0', 'kjQAkrdbREk', '81538', 'mpfSRGHFY0g', 'pqAGD3ijMPw', 'jQ3EmbRIe58', 'CHh6hWo1AFE', 'zqkawTdHN5s', '-ZgjBOA1Yhw', 'rz4Ax6xfZHQ', 'sw-smuVRByI', 'UTNP1roJV3I', 'flGZteJUNYU', '273531', 'QNxiqu1y1N0', '270665', '_iRAn6feOmw', '57618', 'vYOr36tdcpc', '6T1GHj7qwYs', 'wLJohZMqR-g', '220548', 'Sb2xMPwNKPo', 'qaoSn1eEyq0', 'omHQ68k50XY', '270444', 'FNbULlE9RKg', 'cKxNJY7sA8s', 'mzTHW2dtbs4', '3gA34VxBijI', '6TKaGMkO69E', 'YmGfjU5PGyE', 'Zr3psuFQoDY', '3f6xCzKx9CA', 'T4e4Ba1sRg0', 'ogGweZUAVtU', 'cyOSDKOxb1o', '19k6sEC7814', 'YrPXbGBvqGo', 'LQnXVd-PR_Y', 'hGRRlXfH0BY', '254298', '192799', '70710', 'CIqRibqChDQ', 'AIPqRuTjI4E', 'dSax_7klbfE', 'gcGZp9JX_qE', 'zoPOeViAdOo', '3B1zIUj-k3o', 'MmJD4KBT0nk', 'RadU51t1kL0', 'T1icdxz0TNs', 'iREkcXde5ds', '40181', 'k1ca_xbhohk', 'wLrgvSYLPUI', '41692', '8Lmqsakmw3M', 'PHJ8eybXJdw', 'CuFLRnu4FQ8', 'a7HHg_JygJo', 'dqragS38hCk', 'FMif4HMBZjo', 'N188QSyfmeQ', 'f49boM5fb8U', 'NYuY6HVjMZQ', '112223', '3DgOMTs3A1E', 'VA6lVHlj5d0', 'PohW-isYMK0', '248837', 'IKXWSNf4m2k', 'bhPB19tr-JY', '251826', 'omBcvw7izuM', 'IB0lGIxP8YY', '07Z16yRBFUQ', 'yNiJGh7JpLM', '0vXaXWx7Rvo', '5FbzKjx3Lho', 'NG7QLq4XlWo', 'kf3fZcx8nIo', 'n5MU2-GFjo8', '189966', '4qjz4BQCZyM', 'lTfsqoo-jKg', 'ejDe6hQWZOk', 'jV6qzF2YROc', 'Sir2QeCh4B0', 'kZfcQ4a0kx4', 'UK_IXtJ2BqI', 'xsiHAO0gq74', 'CT7QOWbhfv4', 'wd-LTpCtAzw', 'qEkFReBuwxc', 'v3l56fl6aJM', 'bYt4wybVLRQ', '233356', 'afCsKTHteg4', 'wrQVnClcNPM', '2mWPHvbKzL8', 'mud6tEqFiEM', '_MGd6t9eZP8', '267278', '34-ogj6rh6w', 'yZWH2P-h0jo', 'DGeBPk1op3E', 'J3-NEG8uoiE', '272375', 'sU40irMa-so', 'Z-26eyME6Co', '-lzEya4AM_4', '227173', 'C3lDRFu1ZcI', 'pu1C7tmYHxI', 'fhY2vbnjuWY', '210238', '245322', '-wny0OAz3g8', 'LAj3rqJvS3s', 'XsEPZydHWdo', 'wVdoIjg3ZFQ', '72385', 'lbx3eu8LUl8', 'zR62DCEMWgs', '7oFimEZJQ_A', 'liJO1yIFsJs', 'FOMXt3lStco', 'FWBCTZiijEM', 'bUFAN2TgPaU', '96099', 'S8yP6lBOdKo', '244817', '84176', 'bVhWpCvpSs4', 'Wo1RxRjXyYw', '131871', 'jcQi90n008o', 'qed3medhsj4', 'rsQRiALH5FU', 'hfvmQuhqMmY', 'iWBx0CP9JqA', 'SMr2DprlLu4', 'r8OPmbZZlpE', 'JF-5nlUNx_g', '08d4NTXkSxw', '0SfejBuLgFo', 'pbFwuNCQlH8', 'IAmZ5iWHxw4', 'Q8naC1qriIU', 'gXuiIWRxrw4', 'R8Kw_4Y9E0s', 'ytXVSpPfKwA', 'SH0wXyhsx9s', 'yALhl-lMBxk', '3QcqpwQiiLs', 'vM7m581tHn0', '46497', '4CKhrjuuofk', 'aNOuoSVlunM', 'jZTe5cbwwEE', '9Jyr5laC8mg', 'JvLMNXW7B10', 'HD17J-FvROQ', '81615', 'x7ZR70cTa84', 'kRs39SO-neY', 'Te-vgmYgGM4', 'Drhrzj1yhVs', '154449', '220200', 'Xq7zLxYHxd8', 'I_r2CP56toU', '_HanACduNJk', 'f-ZNjqLlrm4', '122602', '9zWeMrfr-l0', 'JvgofTcCSEc', 'OPXmk49KyiU', '4poXF3xo6Z8', '208416', 'SqtZGF_f63s', 'HUOMbK1x7MI', 'w8TXP0iz29A', '5OLO6zEbrVw', 'ai7G98thPpk', 'It6xg0WcqJ0', '44780', 'xn9_4n4NpEw', 'olcPEN9x5VY', 'wgCSuviySwg', 'fnFoRPqkQeo', 'BXqnWuDA3H4', 'G8p4QMjLUXI', 'CE9yV4SearE', 'c7xUcM68IFE', 'BDCFV4EqHjY', 'npIVLL_fTf0', 'RIAEgUKtzxw', 'Gbg8qiKQkhM', 'nTBKtwqPIYw', '278474', '3u_Joh0WJdw', 'w1MxXu5D7ho', 'jlCFLG6rKKY', 'Ta_IgA3XJ3s', '257531', 'NDMAVMZyISM', '5eA5HpyFsIk', 'JkHxzOWOLfs', '238889', 'QDRtKv8PvFs', 'RdOc70IrjJo', '5VKMctXBN9M', '44MVdpDEQJs', '3w9I5SBhHNc', 'DZIFCYOhosQ', 'hIQhkTjNaQc', 'mxFU6TrHChY', 'Va54WZgPTdY', 'Y6s_vuUUsJM', 'kmAisuAFckw', 'mI50zj8cTNw', 'YcyHQQXGXWA', 'OEMSGahoCmM', 'Nd55vByy2F8', 'ipLoS44xfO4', 'io85pRFj_dw', '54CM1_GA-uw', 'JAbFsRxxnFo', 'eY64P27khzk', 'nHMHePX9WoU', '230252', 'OwYfPi9St0w', '1bzS0YF5hfs', 'n2BuwHbdilY', 'kiR5zVo2zvU', 'p18PVgfxook', '9-K1CXCXui4', '102168', 'KF5wgQPp2yc', '7ifnoHhrMtA', 'fI9KptYFZeg', 'rBWeo_rEdcU', 'fbHlBmq7Ipo', '298736', '275248', 'R0uRDh-engU', '9pzn93kdP_g', 'cXu56oK462o', 'K9-KyChw8RM', 'QMAztkqnvws', 'o4b7hjQwpv0', 'ERnYvxojeu0', 'faXGVcVcVsE', 'OAV6KKf60bQ', 'x5xF4yu9Bos', 'ggbV7YeSl7k', '238645', 'RqOgkJbqFXg', '_K0okiLaF9I', 'Gmhi58erY6k', 'GICVzJMDfv0', '129733', 'h7p5URoookk', 'nhD9WSEIspQ', 'frNJdG0GkYw', 'gZDyk95Xob4', 'TahiuVpcROM', 'mgpoY1-110U', 'dYyg91d7zjY', 'xyOa9ivNrg4', '7EWOMjaKlus', 'niX_m3aMxhQ', 'e7_2U4lm6TE', '1ZjIX9AK860', '0hCOCt6fWas', 'N3QuD26DuCI', 'U8Ewftg_8CI', '8F1mj-XT6KA', '3aIQUQgawaI', 'qdeQg5dZb2E', '92521', '6UV6ktwbLoo', '90wZz0thye4', 'zFuRNvfC4So', 'IgenXuE4qIM', 'g9rNhtFG9aU', 'jT3FSTBA8Us', 'nNFDj9fRAqE', '23YlZoucbyM', '245243', 'BZOB3r5AoKE', 'jgNu58Da9cs', '7rMLN0KKE5k', 'nxksB2kDJ6o', '6rkV4QRcVnk', 'asWraTfIqq0', '7R70kKqtGh0', 'BvvttuYysvg', '270449', 'So3bPzg2bq0', 'Wnw1IAEDwDM', 'UUukBV82P9A', 'xP81rX2ATLI', 'y-nEcwAyQos', 'zi0a6r52ZlY', '100499', '7fPYpqzw1iY', '261900', '261902', '-3nNcZdcdvU', '256976', 'KEUVzxC7T3E', 'KUVGWCTT5DU', 'rVG8gOAY0JE', 'p19Hsjx2xgI', '244261', 'qDIh6YNbIMU', 'N7IerkWUClI', '43456', 'pfCPogxnUfw', '282586', '73447', '4ZhIx2ozUIE', 'ZltpfWh2aIw', '266938', '73449', 'QoIsjc4-GIg', '8X5tGQLBqPo', 'Tiq67-bAV3M', 'B1B71X_SmwY', 'UjT8pHMN8Q8', '98442', 'iceSGs0MXaA', '110203', '74101', 'A8plGi4rbxM', 'grePRQ8zonA', '9K4aWWoXuyU', 'Zo8jCDGMWjw', 'I8MM8y1XVjs', 'L0WUuWYNeCo', 'aIUF3QJJOF4', 'K1VeXZxR24U', '259260', '708sewcSXVY', 'Wfn7XvSEwUA', 'l-nM_U1qpko', '128752', 'gm4l099casQ', 't7a3zECpT4k', '9BceQC_SdTM', 'trQLgl6ncmk', '266396', 'oHV99Y_EWfI', 'L382XZ6iZmM', 'X0jMZoxUL2A', 'D1I-Z8jaby8', 'z-bupzylxEc', '125730', 'K62NK2KYhws', 'jYT3-RQFy1U', 'A2E78CGi5TU', '7hSWYI99-24', 'eeN7l4R3nPc', 'nmWplIQhvoA', 'UtuTyW9pUN8', '83859', '101851', 'G3RPgs_7l3U', '5R5fDxZUL8M', '5PqwxUYIe3c', 'd3EeIRaMbbk', 'qbIajpM7U3Y', 'Nmd50Uzyybs', 'Jh1uDYOJMwk', 'AjgDuPEp9sI', 'iMG962Rj3Vw', 'Ua4g9q0r-dI', 'kU6YY2z7z0I', 'X7-Gbk8gAD0', '856LGms_0s0', '9cSJglGi9Pg', 'rZqWAnrJ1Nc', 'gEgcpVY8WK4', 'Bg-PA5KTjNs', 'SWHmteF5Rlk', 'gr8mzv2xZ2s', 'i6UngvEEuNs', 'yuwvVTnsDjc', 'ULtBuI6nMaY', 'sIGAq2J4KKI', '4EEru3cZwXo', 'qlDiE1d45Bc', 'Xx7Y2YIbleA', '225416', 'xomMHflvVDw', 'ahcAFnY6iAY', 'Gvg_80PlAAs', '216007', '3DOrdP4H8SA', '186631', 'zaTyjiyrHnk', 'AGM-hNupJik', '270956', 'OiMkqEH5WeE', 'vM3YB7LmMq4', 'M2Pb2kx77ww', 'lVj6ZdyW9pI', 'Dws8ZrzF7xQ', 'taCchyi5h68', '30763', 'SuKnUzid-1g', 'E8L1Z71vKG8', '9zBj8VkRBpE', 'Q_py5n2fQXw', 'VUrTT7xsrec', 'ZdX9sUd3bAI', 'GpRDC-S88dM', 'hmjfBZGGZR8', 'wj3ur4fsiN4', 'DbAppk7xT0Y', 'ABSC1JNdpTw', 'cnllFPRyBFs', 'fbSxct2JcKU', 's1Yo_MCiMPc', 'EoC83JhkCAw', '1olbQVO_C-8', '0p9XKC_J3hU', 'rv1gp0wEhI0', 'HByf7qiO-Kg', 'aFjMWlR1QAY', '424vOT3Nnyk', 'jXp595jj734', 'GxWLhv-Vt78', '110788', 'TxJjAK0WrOY', 'rLHJ_ebXCHQ', 'v2DFe9X-jCY', 'tRSPfPlNbMU', '1fqNb8cfLFE', 'ZUqTWOx9jYU', 'PN3ApHIGopo', '_KGd7IpX3B4', '38374', '266852', 'R0o37yJ1PP0', '245497', '92533', 'RKP6j28FCWE', 'PQYmOknHA4c', 'q4hP2j7oewo', 'XVSDfgstFUQ', 'W-ptEZFARVo', '127539', 'CqFt3_uka14', 'I--8nRKCkJI', 'bMuoPr5-Yt4', '52839', 'gAMbkJk6gnE', 'hlYDicOj2m0', 'XPoY4LD-A1I', '9sAoeFTKILY', 't2U7w3K2qac', 'VgqI1KRnDSw', '92331', '220134', 'LppEvM60-xo', '1ESU5ONMMxs', 'FJgO-FICHlA', 'KLy4aBLqwCk', '256935', 'GTGtVdAuyRc', 'JzydLJw6y6o', 'flBtk736di4', '69NtV79qgOg', 'q-0gu48ClF4', 'm7SJs73SF8w', 'L8VjQM9HQfs', '5oEuiBPUTYc', '4qVvLLFEYnk', 'cWN1bibicHc', 'b7DK08bWU6c', 'zKNAu2CCeRs', 'YfxtwXXkCmc', 'DR9Hhpy8aA8', 'kcIGTPHEsNo', 'fzuTEKwNS94', 'v45zoIrjoTo', 'GOj7TBcEA8E', '1RBT_QoSkIU', '245276', '9K5mYSaoBL4', '-aNfi7CP8vM', '292277', 'ymPQOY2O_nw', '21137', '208148', 'aDvgbBqTWWE', '6PLlauWxF5E', 'bCDfIJ12oqM', 'MbpPBLUjpV4', 'hawztAtYHCE', '45c3QQzGakM', '5XX0csik6VQ', 'bI3DTH2yTbM', 'k8NgVOCDYKM', 'WBCRTcMJZZc', 'k5-3KuvCFms', 'w44JDB1NmqM', 'SaNXCez-9iQ', 'YcJ5RJYUr7Y', 'AepwIhSbAws', 'y5JdqGL5DRc', '261267', 'BseI8-TYWm8', 'e1E5W_ZefmY', '125895', 'AGFgaKPzjMQ', '1A-aRhYx-GQ', '_8pvMpMdGM4', 'TfBVq9oWBmM', '_Vp4SDp_knI', 'TM7cHOHfF70', 'n-sgVVTE9Io', 'HWLpH3NMtFs', '22821', 'SGsiGz2fdpo', 'uITHY4LORDs', '2h9VVQUZjK0', 'jZnFr-Mzj9M', 'GJyzeK-Cn-0', '270416', 'QEG_hkJsaYc', '2w7rpDe-HoA', 'TWf0XFpXwfs', 'JYdfUNjyYxo', 'mNurUl_Q2UY', 'TNwwVWA-oAE', 'G1Z_JUTgZqo', 'bfy28AlY-TQ', 'mL2v-sODUZ8', 'jjbOD6u7V34', '0Xs8wJrAmxs', 'uyeQsv2tq44', '208299', 'wtCKzu8eVJ0', '87MsiC3E2-w', 'mxa4KXSz9rw', '264418', 'SYnygYs-fAg', 'YJJoYkFPmds', 'wvMA0r3esw8', '238060', 'Uw1nWfSuyo8', 'Jz9nlw15QZo', 'WSjlhBDxNW8', 'Zg9DKOHJdw8', '244836', '102184', '3paDwuRQP1w', 'MZoLQD83R-4', 'IiGzuoblKSM', '215259', '_26JmJnPKfM', 'RST6PgpsLws', '0BVed2nBq1g', '2YwgSmmLibs', 'JGZb_ygtB0g', 'dbpGH5iP0GE', 'U4-u5NZLA_w', 'Zae-zQ3VBpY', '89951', 'GSnt_fW8qjI', '233366', 'ULkFbie8g-I', 'PbyI-sUzLZY', 'SCXp4l0CO4s', '216857', 'AHU3PUztC_M', 'RdExUaEIWIk', 'zwTrXwi54us', 'damyXH7mBic', '224599', '238683', '22880', 'Cb8ay6WtJuM', 'zrFZAofNGi4', 'Rt9rN1ntS3E', 'uBgRo9tnv-I', '202810', '_4K620KW_Is', '252177', 'rApOTQgFW6Y', 'Rugd2NMu4bA', 'ssH8WQF4eN0', 'IlgnbEdOhmI', 'HS-2vVP95u8', '0zl_GDVzykw', '126831', '130426', '60Qw70Rd9Yg', 'kY64gXOapYk', 'MpuWcGn2Lcg', '119348', 'sKwPCpFtUUI', 'YRmjALBdTdE', 'FylhSeozvG8', 'cSrM5mHACmA', 'wOKWTFYYMuk', '209775', 'jzNIU-w0MVo', 'znNt--6itO4', 'RE-LIPOFnrE', 'RvIohowRPAk', 'ACOlIiRdDyE', 'Y9fvHRNz2Bs', '2-4autDbHVQ', 's53UAEi7JEY', 'r_vjlTcrI-U', 'EpadyoYlAjQ', 'VjAvqFXEmmk', '96194', 'GkoBk5K-FH0', 'gv43BPYYxKQ', '0WIwQgH4lKg', '140293', '7sgAWvbLtiM', 'q7BxnIM2_z0', 'B1PzCwfgXyU', '6ng8CZ0ULK4', '0OXeN3MhFeA', 'JW2HHfQiGVs', 'uQds2dN1AiM', '_ZlF5Q9W1DM', 'icIS9VfbzMw', '231025', 'HgDdU_RB9UA', '128949', 'qFsGMA75-oQ', '270628', '2vX-ZRQQDwo', '95mDHiLeDCM', '18QjfdhJEM4', 'Tdw0fJt0lco', '74870', 'LX2rT5C3sJs', 'iex7I7iVnLk', '33ueXDUn3mA', 'G4HMKRdIva0', 'tw2xFbfgV4U', 't4-ZulW5np4', '236696', 'zURYO3k8lW0', 'wfLrS6CdFs4', '219310', 'L6pg3DQKoH4', '80627', '80620', 'oj7A8mpuBeQ', 'xNYsfeSgDCQ', '11650', 'afDJvn5nmtY', 'YY2yjEEoB3U', 'pFh-SLxltms', 'ZLCK8WX6qFQ', '1F0qH0EEBfo', 'VzDXgBOe5iI', 'L2uC4_Co9uw', 'UPghCarcnMc', '3ZmLhK_YHl8', 'DaXkixKFEvE', 'Kpe5fISxRTg', 'QXPOQW2tRBs', 'ZW4Oe_fKJM0', 'We5nTulz1Vs', 'j7fRIGphgtk', '261326', 'oecQ9yDtfx0', '255224', '6vbd4o5rIjM', '4VA4kqMnEqA', 'XCyngF93SmU', 'zWfDRPy4lXQ', 'ZXHX_e6HCI0', 'tdIZZ9v0IGA', 'OSyKmOye5Uo', 'iR1Os7FVGHs', 'Nzh2KkaGwrE', 'ysGFcG_PI5I', 'oZkWWCQw2Js', 'iM3wSwoAtwk', 'Lxs_6Tvq12E', 'erBIIKA6r5Y', 'sK9_de5Jx4U', 'VoETCD8fBLI', 'DQ7QKE3hzVg', 'IawsOlEKRf0', 'pf6HYOOwfGE', 'z8bWG2z-bMM', 'ZZ1IyZaMTWQ', '33439', 'MRU65o1odI4', 'V5lfNohNlEg', '4hEWns7JBg0', 'qrI7XCKRFNk', '92tWNUhG9DY', '265959', '30162', 'SWhfaL7AdEc', 'hhK7q30p0Jk', 'RAiO_rChmdU', 'BRzjQHYWbSs', 'nKiC9sEP2vM', 'AlmUwZgY6bs', 'etPDgRjrnJ8', 'qP4uuMI-JSk', '255343', 'Bf5owLv3X98', 'LZl9Sj1safM', '137827', '233171', 'wxxqXK9x-64', 'otna1VHHCow', 'GMjQUrlMa50', 'wlrb0HyIs-Q', 'q1_knonj0Lw', 'o8OZGBDPD8M', 'YF3mDOuF46M', '271594', '-vxjVxOeScU', '8ovb-GaZ3QE', '6MloL1gIccs', 'OxyQSJMvWBo', 'W-pA0lOGLR0', 'fjE2EZKgQm8', '271598', 'oyHKiX5YGDE', 'c5-L8vC6_sk', 'F5SGdvSRJmo', 'R-HKj8Yn06k', '288714', 'zj4PzGtFwJM', '3aD0xAgxxyw', 'PYylJk8R9Ak', '110766', 'JdFaSggG58c', 'T-vqHR989bM', 'Q2uHXKA8cq8', '3GyEnzE1NTQ', '131650', 'mRnEJOLkhp8', 'lzyVWNrkgbQ', '225343', 'sPxoGNvnVzg', 'jPf0LjZAS14', '206606', 'Rse6laKf1i8', '50453', '8-Hi9NmF4rM', 'yDIFWzOBjXc', 'S_tGoxSEh5Y', 'dsob2MgUPpA', 'OFBc3z99bIc', 'ta26Z2YEVMQ', 'TVhXqAI9gyA', 'FX87sfrE47w', 'E_oqbJatW3E', '0FA32bEZ6xI', 'gzZ8NTeTzRs', 'FvoZgWvc3gc', 'XyBU_gZtU0M', 'UKVwc6I06x8', '2QOf2wSu0j0', '225768', 'AVScVfLgNmw', 'dLzsNc_hzkQ', 'o2miCpS7Hwo', 'MnFRVJtHAeo', 'fdK_tsvBXJ8', 'x9E8yaFCX0Y', '2f6ZHqJ76EU', 'iS91daVpH2E', 'FSGL5K2EEdo', '136205', '282560', '271366', 'JCg26b8EO48', '5qxZFmIaynE', 'GUffC7vu9zA', '257045', '7U_z0JfleAw', 'QQVRIGEUa_Q', 'StgqrTr0JqU', 'ATfnMuJJDkk', 'uea5xJZygsc', 'RfKxYiFd-fs', 'gC_wF3uKFW0', 'e0ltF8zpEcw', 'GjCUDqWSI6c', '9Un1O2ypJmI', '_JcML8u5Wes', '6Vg10LxmWUY', 'cZDAM6NjBzE', '6q5uKCgairk', 'eo8L7lCTjDQ', '244180', 'xRJXYUZVdas', '_iy7ftq27xE', 'YQUutkMdLj0', 'avW2m6VHTyg', 'ZMAoUt0SD7E', 'i5of7ZTkyfw', 'icehEYAiimM', '2RC_DXV_dPQ', 'tvE_DucE0_k', 'FP3o75bpi8k', 'W40BaML7mzc', '121358', 'skp_SpnIOCM', '224817', 'r917wP1qsL4', 'N7tS7A0WWpM', '3oHPsYc8bmw', 'WHUHTmtBJWU', '0nJrksJ7azM', 'c_FJuhSte8Q', 'plsot5mFAtQ', 'Az3e1Opu0LE', '2c2fhh_Dsoo', 'GAY5ICoVnA8', '125708', 'nErOMpqvcRg', '45186', '45184', 'REkPZ77s3Vc', 'HQ2LwfRcrVc', 'a5FKWiI90hk', '93821', 'OEesmAnTpeA', 'AmGocfFQfVE', 'khw3YCTFLfs', 'K_5u2Wh_wGk', 'cZVM4svwE90', '210618', 'JX-mwjSw0dk', 'g99kISQbyuI', '209354', 'hj1ph17-0jE', 'ep3IasggD3k', '0rE8jEvQW_I', 'XEZ7e4pf1xE', 'rexJoy4RMdY', '122842', 'IW7IssCKgmI', 'pttwIaJmfcU', 'tXQQ0joMq1Q', 'Ob8vPQCPDX0', 'sFLTjqVS7AE', '295793', 'hdLC4Ro977Q', '_WkXQNVLQXs', '190740', 'WovurMxG2Aw', 'Sglx7douG_4', '984VkHzXl8w', 'JwzxqrD8tIo', 'XQxnAPleuCE', 'obnOnuzb-Xw', 'wI7DDCRh4Nw', 'mXdvCxLbpuY', 'nZEPf7a8GbI', 'v5AAvrZuR2U', 'pf-78LF4ORE', 'L_XttWZBKss', 'Yi6Qyn4X8is', 'fTNOAssiTYk', 'aFhT0px8AMw', 'kh6eynD9OIk', 't0Wi5Nb6kbI', 'kM6wo2bb3nw', 'Ry2NJPd4N3s', '10223', 'v0a8N7Y-Vfc', '1JQ9UCBEmCU', 'vop7tN_K64I', '15837', 'VN1IPN1TL3Q', 'wCbQxI_-GKU', 'gPWyANEm0eE', 'FfavRdRKsAQ', '40260', '80914', 'O8IJh_L0EfM', '180923', 'zcG0ms7CdBE', '12812', 'Cj7R36s4dbM', '219775', 'dyZdiWNflko', '298774', '38019', '4wuug3-5cWo', 'VDjnKdFxuBE', 'uYzZB4ccG1Q', 'WxYb2x_irTM', 'XXvSLz8QmGk', 'EEUGfVTyTQM', 'emtvrtk-jsU', 'xPhlDO-2Foc', 'c805Td8A_Ek', 'N0Y7x_fJ0Nw', 'kkaX3okuvjI', 'rWjPSlzUc-8', 'TJelZLbfT2A', 'krHZuqfXrPU', 'gRAmIaSlm80', 'QMEgjkpyVzQ', '110754', 'uN0d3ZOkDp8', 'jakiZQd4boM', 'cyu1HhakSaQ', 'VVZLA2neYyw', 'MPRqaQqrd9Y', 'SMzV26l6iA0', '106514', '224772', '1tQOvm5eQOA', 'X2leyjuolDM', '218708', '239572', 'vXABB4tBBUU', 'mRPIse3OO74', 'HqtvFTa29L8', '241164', '6YNAmRjpxlA', 'VhKJm_jiciU', '8404', '206507', 'LUKIYWa0UGA', 'VAFdgtqZz4g', '6TDXQtGUNEs', 'TUzD45ghy4k', 'tQk-eoA7JyE', 'nDXKvarLEOM', 'WAXJRnJXmOA', 'a8WV5KEMKSw', 'ItnyexqXR_U', '136215', '136211', 'JMzilFvwNXE', 'bEXCrGIOoWU', 'xwNQ7QuXaps', '88888', 'SSNrLu-eZiM', '83_N43pvgHI', 'PUIsiLk8etk', 'KSyX-lejDcc', 'ou6S6fbfBWU', 'wQkNqbrAlB4', 'bcns0Gu66D8', 'NSihgq4R8Z0', 'jNdvceZ4etc', 'YgyqX4aZ4tE', 'AggyS1coOb8', '3HRnhUin-5g', 'Olx-sTx7HTk', 'lEsFI5YJGDo', 'KD0w4BrNXQg', 'gjEYmdWrBLM', 'I5cS_TlV5B8', '88245', 'BnWvk0YRgE4', '-aqamKhZ1Ec', 'L3b9wwZ8vRQ', 'ZfQYEa2fHGo', 'oNCvb0F-c88', 'o7vcTMAX9fQ', 'ieWQdiQAh4M', 'ZbVa-a2tNFM', 'SLi2gT5H6m8', 'd7Dz34-cZ74', '3kNPvhdF1NA', 'mHIvH6Nnrls', '7wiaDbpiAQ8', 'H-AJ-grXvgQ', '277991', 'a4vRa-_nuJw', '4wdeBJ39Cuw', 'rCQYq4T8SEI', '1YEgMQ1xxzQ', 'CuF-UOcAFG8', 'mHEtr7PHxoA', 'oGnKsroR0R0', '125845', 'tXxXhGD1aMo', '4GYfmpEEtl4', 'jhb6SV2dQzg', 'qjMyjLSORY4', 'mSWwz7dXUP8', '93839', 'iFj9wJaJSPE', 'hOp6I4jGvu4', '_bIJOxiIJFk', 'lWvaIexY2WU', '327283', 'kCQqLNiO0mk', 'KPeos6f4HuQ', 'm8tzdtrgFUA', '2HP4KedfmSc', '8VP1qxX9mh4', '113265', 'XAazxiP6tP0', 'sRex0-9yFFc', 'o2bNnLOEEC0', 'YLA7h1RTa9w', 'QYp0lGhyL6A', 'rwe-hBNpzH8', 'QWaUvAL-yiA', 'jbJF3aphcP0', 'f5k5cF80aUE', '663uRzFOfrg', 'OdKp0hYomgs', 'AKofHsmxa1I', 'uyOrVTq8Tjk', 'Zs8x712Y-CM', '80866', '94ULum9MYX0', '_tBaGXNwlp0', 'AuPCZlKBzq8', 'qYJtbgLqizk', 'm0-DH0k115I', 'yyToAEoUuek', 'veHYwR7ge6Y', 'nsLACXjD4KU', 'ypZhKsR-9iI', 'sqADHmnM164', 'wRKVNiABc0w', 'tgrxA3CiBv0', 'RLHZ6xtIWSM', '4qoB5a6dR3w', '9pdyTplXwM4', 'cMUS4nhcKCQ', 'kSooCdVTI6E', '78577', '65kkuNV921k', 'po5jCjnxW1w', 'nM5S3xxNOlQ', '31tcuDMQ_H8', '47472', 'ZQuGizjoCTY', 'xXIq7YPkdUQ', 'K9faaGel838', 'sFxUNO2HOKY', 'yt9GpittX4U', 'kddCewAsxfA', 'YjNYBBs1AZw', '108793', 'UgTM9y2rD38', 'TO5HjoK8Iu8', 'pkH2TfFN-6s', '-3g5yACwYnA', '264446', '238039', 'cEXJ2zFbC9I', 'Kmtib-wZ0jM', 'FmE9BtTmxnE', 'CVx494kExvc', 'fSOVk2cS-sY', '3n44IP3tCVE', '1k7br8xXMSU', '53742', 'mMeGgB9-hSE', '206376', '27ubp7CLLKQ', 'qFppeQvdfxI', '4Q7OkrJLzAc', 'YWxvIFmYnNU', '4oeKDFIaL7o', 'BMhG11CXgww', '7eJqqvvziQo', 'i714Xt6eb1Y', 'bzPFUVGPS3c', '2PgJok07td4', '3ocpWAmSNUE', 'QLEOYF7Mju0', 'XzhRYIeczg4', '4iw1jTY-X3A', '78Ncka6CY70', '9bAgEmihzLs', 'xgAwddSkrOo', 'ce1ObTPlI38', 'hntnelpiyl8', '8XODJwsvBa0', 'A8c7q_P4jQg', '8u5aet7s9_w', '3FpmKxZgihw', '202990', 'Rw2pzFGosmw', '43371', 'ZzL2sHtTWRc', 'VbSsGRXIwjc', '2HmBM3GGTlg', 'hkGN5q3OOCE', 'eOU_40p9RpA', 'vttEPA6Xffk', 'Wn8nz8GPKkI', '193291', '0EAAfLCQabY', 'MBDZbACupsc', 'oW1OEsP7Dds', 'JY-krIuEUm4', 'rzsk_IvI7bQ', '241172', 'yG3wpvLUQcg', 'XDVkhOziCkg', 'yrIXBklJ5YQ', 'K_K3wpxkRc8', '75938', 'DiOw-w5LDJ0', 'wOjnqud5GBA', 'kx544gnOZB0', '266366', '6slq62RwH3Q', '6WDchK7TuL8', 'n4xRx0J3rYQ', 'oK951Y2N_k0', 'izFBeXMTgds', '276217', '8Cp8c-eQELQ', 'hfK8QtTd7fo', 'auTpzciNgls', 'xge9aYTxxOA', 'mw_ZwML0SbY', '25522', 'Y6zyM1nDhN0', 'QkMTYY69JYQ', 'hjBQmIWiWgw', 'C2xNDBU2Z0s', 'wR3zalLV_6c', '-tANM6ETl_M', 'C74-of1rjg4', 'kzmaKnujN64', '2Wo-0trLBjU', 'lzVA--tIse0', '2cwNG0YuwtQ', 'z6E-ocntPo4', 'd89Z_olwc2Y', 'iEOBNT0HFtU', 'ePiz4zU6crI', 'P35dyIit1yM', '106077', 'ADYia28RrFU', 'YD5vqR15nco', 'XFGHTk_3hGg', '98187', '5OXuBO5buF8', 'MroQfGehC84', '2LpVvLemgvw', 'cjgq9d8Zn9g', 'oWAyEzyp2xQ', 'w4xIyGs-3wc', 'dzSv6GwfF-0', 'S_mxvk4LEh0', 'KQ86HmgwUns', 'rNXM3avNBKk', 'aI1tdJPHz2I', 'axQ5CDRawO0', 'sC1NvtirijU', 'c5AJbOd794U', 'F6Ci45lP5aA', '0jtdrsmVzYQ', 'EOkdFMw0pmk', 'D-DqVICJXBU', 'r1erb5PSm1A', 'dLmtsRyRH4s', '247382', 'Q7nhtfkIPN4', 'LityRNuQihc', '5Fs_7A_V2kA', 'OEOkmrKvTUo', 'dZK01jhM27k', '4Fw9TbWIVJI', 'N3vSaV8Ztrg', '251417', 'hSEfYcIjIr4', 'TksWzxo81Mk', '9XCmrHbU-rU', 'IiX1k0oYW_w', 'zx4W0Vuus-I', 'lKTeLK8nq8w', 'e-2QlzFeyNU', 'RTzDzj4NxIM', '7UlSX-syPeo', '6E-yr6nPxGA', 'pIMByitigYI', 'ZDz8Qr-sJ3E', 'L5a2ijeWpUI', 'MKShLlJ7X7g', '223926', 'IDVbPEket6U', 'G38DwNDQ8Cc', 'JW3OfSCZlhc', '2lj0BaPsJpM', '0JuRmhhgMw8', '25t8nrkUfRY', 'qlDT-bmIzQI', 'MJnc4GUhUuY', '197778', 'ixZAEncExWI', '5QXHyL3BMto', '255226', '238023', 'babuyKl7EAw', 'qo2reupzUE0', 'oDznO5w3v0U', '284673', 'jEQoBvc7V1o', '288766', '8x81fzwcJko', 'mQTaEIrNxnQ', 'yEtfjJOMMCs', 'Vv2DTPyyw90', 'Gg9ZcRlwnbc', 'pAclBdj20ZU', 'CXojk-oSaEw', 'efLrpnuLwyU', '87161', 'C8Fhlk-eczU', 'pjWLxORDDP4', 'YVBsDJtAbk4', 'VcZffwwL0bw', '4Vl6AeEkAg4', 'JLqBVj6f5gI', '31197', 'k0cGUNUHuyY', '03X1FwF6udc', 'N0GhVkCwrqw', 'xbl7bU5PGBs', 'K7KEtrgBkz4', '4H9RfQuqsvg', 'l8LTcZJ-_8k', 'BBSVLGf7zPI', '267799', 'nHP7l5zAwGA', 'mziQcFSsdRI', 'UXvMaHD9kmA', 'ptgBkE_e5js', '4HazSkYihtw', 'PGBrZLC15yA', 'jFNgOznarMo', 'X3p50qqFW_w', 'BuPhjBayua8', '229903', 'jbKDW9URnvM', 'Xo6-V2RlWss', 'DNzA2UIkRZk', 'jfSGWBfVNBI', 'MFrwi-RibUk', 'kwkhYpCHWPw', '1cyUKHOvdYY', 'qrSW93EtuMc', 'TBwetweXRb4', 'hCFV5VLgS0A', '_BMdEKNF5Js', '88797', 'IwQWibE8EOM', 'eW1vgHE6FRM', '1sJjdaXXuJg', 'wUf6AvCMHbQ', 'O0Nn-5UkfoA', '1CjUHNYzW1E', '_PJ26YwqRJE', 'tUTf9R5u6r0', 'Ve-mmCM8TI0', 'kuQWPuhnlHs', 'XAT2IfFFAU0', '8M0AlvtMrv8', 'FLyWn2DCci4', 'WaaSYRPwQBw', 'QbJiphIpzYc', 'H4w9mU8B3Mc', 'oCsrnIomHos', 'TxRS6vJ9ak0', 'VugBIVwSmaI', 'HObh42PhOfw', '_4PNh8dIILI', '251646', '_PKP676ez2c', 'gjSyl6evrWk', '3OuNMjZo5wg', 'cRFiXLzcCOA', 'cAA2mONG98w', 'NZtIGzAzJZM', 'xnNZyfhusAk', 'gfHrSg3BwiQ', 'PANWQeBKStk', '4Z47qIrVil4', '45175', 'IkvL4IAiZog', 'MyDLelMxt-A', 'ZmAIDJ_gcXM', 'JlmpDdm1A1Y', 'soqnBdPOwoo', 'ge071m9bGeY', 'hThsntvCk2s', 'cfX_iuhCbRY', 'ouhCx4TgHlE', 'NuRvTWhELqs', 'x92920ole0w', 'CZigX1ntOsI', 'QWzIJuhLLrc', '94983', 'mN1Z5xEOy10', 'OoOD_VBL0i0', '274219', 'MvFFYObY9A8', 'mKP6TVuixWg', 'UuR4Rw38v_U', '0cBmQ_ItVUc', 'iMss8xBhFiI', '107551', 'dbH51F5Zqi4', 'kRsA87VU6EQ', 'S6S2XL0-ZpM', 'gvrfI9e5xHQ', 'dXMAS2tIknw', 'muOYAxkG-Zo', 'MOfEl_1dh-g', 'CL4hDu95Eqw', 'K9U2TAF9DDY', 'ITQTVfk9Iqo', 'McnbZjgCPLw', '70420', '5qQs9Cfydo4', 'DEFDuYyc-Xw', 'opHUZsc2WO8', '_BtdwH6mfWg', 'zwRBZisdpQ0', 'GMnoxaqqReQ', 'CK31s0kfp-k', 'GRFXnnrQaB4', '260011', 'SRP5FYP71Ng', 'X6-jJO00DMg', 'q3QUybiOYeU', 'EZkOWskJl20', 'FmIS69vB12I', '8UH0aPUf7sQ', '_2u0MkRqpjA', 'd99mfGIenCo', 'RS5WM3q2ZZQ', '1rVly2oeBJg', 'dJ5MXl66-UQ', '2Vtv2gPzM7w', 'kKkZihSbxF4', 'n5J1ZkGUGnU', 'W-q9bPlMIVI', 'EHbZ2EeVags', 'qvIhzmujTi8', '32j1yMF37hA', 'cOcNe3L4VAg', 'bU6CgE_kMRY', '5JMpMKAO-Mk', '9JqwFRCTKOM', 'wNx1ZnQ0MDQ', '283495', '7eWclVCXOtk', 'GMHW6XEO1ms', '4BoE-woHtwA', 'RImmdklTOW0', 'ap465Tlzf88', '37117', 'dDFyJp_OkeA', 'fTKe7E_4OCQ', 'BRdw-_dbJXc', 'Rdf0Psjyrwc', 'w_qYZSVx2dM', 'yHtR71rx16I', '262226', 'yOQHOiswVjc', 'QUpI5kMw_nA', '273314', '97095', 'WYSomBHdl4c', 'fW1pK2L6RgM', '243338', 'N0pKIn6VhOw', 'he475nnmMi0', 'YodtMIsjM0c', 'HUH9BXVmAig', '89787', 'Mw4EZYZAd9c', 'Itqbc2TBXWY', 'Vw4-ae-ucHE', 'dEBug0QYayY', '106941', 'mOnyMWhb5Ac', 'OIJr0voCvVQ', 'EfQoSpEZa0o', 'zPskvGHHQtE', 'MNLG4-diuYM', 'PtH_8O__EAY', 'xTBBDx3DkXQ', 'd38u9n5GOLM', 'aEaM_LOI-BM', 'xfP0bm6Z-7E', 'BAi3ZJo5Vwg', '5Tqu1IXJjGY', '8VB6pdJTpX4', 'aZjCq_hv2Pk', 'PMH4mdJeojE', 'WMzvDL7b4sM', '7Vp6Lvin1rA', '-egA8-b7-3M', '239235', 'MMaEsDdBsvM', 'Ns_h5IVcZ9k', 'Ha7DMd_iKyM', '1A7dqFxx8wU', 'xBsrNFxnnuY', 'HLFaW4oVP9E', 'QE0pAVSPsKQ', 'eTCnM472-cQ', '_xjBqNfiEY4', '2RDubrUjI-k', '206049', 'MFXQH7ZlBJI', '3Wi0if_L6Ug', 'VZqkWIPmH6w', 'XbolrpSc0KU', 'uU_3tbZ1zG8', 'bge5PUG3G4A', '130633', '0r8KVXUCV6c', '130149', 'H26MMmrHTlQ', '114624', 'bJI7-LnKPH4', 'qd6YuFGcBGk', 'KR4MpF0YtgE', 'FX-YgVKC1AI', 'YITXOmhQhYE', 'Wh6sht7xwqQ', 'SxbTZjZD0vU', 'TWMFQED1Myk', 'UtjenieM1Ak', 't80DGfWJ3fI', 'CZVmxwrWv34', '36098', 'ZiM_gkdFGJk', 'sMnbpyFqrlE', 'FphtHpVV-7w', '-tPCytz4rww', '79935', '79934', 'VAr7gJydnys', 'CdB8QBhFccs', 'Oj3XwBBrzXc', 'kxcCxbsKx3w', 'cM1Zuji24dI', 'fGYbbP8RDLQ', 'caLWajc18Y4', 'ltA1VF_DUSc', 'lo0R1mvjDT8', 'FdTczBnXtYU', 'WTF9xgqLIvI', 'owT0_Xfu8a0', 'NCJTV5KaJJc', 'MyfRrTjglm8', '2Crezdbre6I', 'i5bmKlHv-SA', 'aFZIvp3SgHY', 'fDYZINwIs_A', 'cR_KQlNhoNE', 'sn1fEo72gJM', 'TZXcQemh8n8', '184784', 'jUKH63mltLE', 'cSraseCDilY', 'Cd0JH1AreDw', '291121', 'cmJW6mkspkI', 'E_ocLuUw-1I', 'eSHOcLD5T58', 'vrgwwihTxVQ', 'SrMN3rwvCsE', 'PJlDO21zl88', '1o8Gy4J6WSs', '222116', 'vbVLgaP5IYU', 'Wx9nThz5z_Y', 'Ctc23Icfzvg', '255338', 'mW8eL4e7Wrg', '112631', 'uxHBEfIhY-E', 'Gljee9uq_Rc', '275620', 'qszy_WSRFUM', 'lpF-yBYou0s', '4lKz4xyCmkk', 'xw-Blnej8EA', '367506', '-lqc32Zpr7M', 'A0aE2Gzym-M', '90172', 'eTn2P4wmFr4', '1RxliidxXyQ', 'ICeSewdyf34', 'XwOdPYlyqXA', 'assx_NKo-L8', 'ky7Q5onqxGw', 'b_SffSbPVJM', 'ctMCSUT2LlQ', '126542', '234587', 'vlnKSMw5v1o', '290088', 'ShgrdU9WAJE', '4HAC00EAdno', 'Q5YU2sLKVL4', 'u94VPxEIJPg', 'fB816aeHRFk', '4Yxe1_ohz7Y', 'hp3nsb_eIc0', 'vNID-RVhWcQ', 'K7FiMf-Dmwo', '29044', 'oO61Ma17tRA', '3OMgvtWNHp4', 'xvnFF0FiyS4', 'GtRxTvuF6J0', 'vx8j_4DMqh4', '_XWUKMkxa-Q', 'vRhj2bLo1ho', 'JWG_MUy7EWQ', 'rFHIApgUtoI', '257771', 'J6zbBfzW7a0', '6xvVFYR5di0', 'ooGB4BLK9PM', 'APYv5s4ucd0', '241638', 'MhojeOmmjC8', 'esnOE1LefKA', 'wEs7pJH2mqQ', '6IUj6jyoTl0', '367576', 'wb7CfuiIZFQ', 'xlNDpmKgSIc', 'UkqTwAuA8jI', 'xPN38lYBQv4', 'xAApNMTj3as', 'TbZPa_keawc', '229967', 'SmftC-VAfYQ', 'tnhRxo-g3Xw', 'wXuBJvzeC1Q', 'OcqJx_cRc3Y', '273237', 'tL8RzwWSmAE', '27798', 'xaSf1d13WoY', 'S_ISgjJR1bc', '234053', 'N_dNuV-4iAo', 'YB9EUgrzCCo', 'UF9OlX-QNHU', 'xiRUWSUrGSg', 'LUf9vbe0TcQ', '251839', '221740', '74184', 'p5LEk2u8tXk', 'VybXjsmsjAY', 'o1cRmT9qnOc', '6J_yzh1LNAE', 'dCDAcBR505Q', '26WrTHLJJIU', '227416', 'GeSTiDe1hG0', '206051', '3J3Thmd_vks', 'vRydHjRzDX0', '2JY5HXBWO84', 'vA68fTqDars', 'DgO5O-oDeX8', 'YQanVofsHoE', 'BdqoZ5qpz0E', '51224', '6aoTjlvo0js', 'C03473pYcRM', 'xu53lk4dhSc', 'ZQaGGpcIPHM', '3lkn8MS3n8Q', 'KgXuILFtgJQ', '224869', 'A4dzxgHDhF0', 'bZ2ytqPtyK4', 'WGfGxoI05ew', 'CzstrpOTtgo', '55156', 'WJ2QF4Kw9Y8', '60037', '88119', 'HOCsiS0pmf0', '5F-KEGK9eXo', 'xXGEkDhu94E', 'qJBQH14qtHc', '4Q95Lg3Icho', 'pzUplbeH_fg', 'dH0FmwvOzs0', 'gLdRUsLw4CA', 'kj63uF0RhW8', '4kF0U8kIMp4', 'zv0Jl4TIQDc', 'gr9YU-UTJzQ', '0EphpADwdPg', 'l5_DDqck4Rs', '134252', 'xfeASyC6PPg', 'Emi9cw9xa00', '81668', 'sRMdbZVjhis', 'j6R1NTrosuM', 'oaC1UATdtAg', 'Bo5IDtP8_Fk', '7xiu1tAJ2d8', '46604', 'OUjzDchhkIA', '244623', 'pvlmYjQdRmA', 'nz2vkMyqfeE', 'OOh1_ffKOKk', 'SzJf6viBWBg', '2c6Gb73nx4E', 'MCRCXXPqFOI', 'vqBRkjHWjXM', 'fOxg1NstCHA', 'Q5uYByRyswI', '4lro65JwQdc', '122439', 'PybuzkS31J4', '1tuMFJnlXJc', 'pYUTSG9frAk', 'vwUBtNvjrU4', 'Uiq0lf9ibF8', 'MNXBOeiPhec', 'JMb18N7lQ0A', 'EGA6iulTr00', 'kPch8YhNfPE', 'taGs3-SMoYM', 'uTWeng4h5eM', 'kyPepNmxaj8', 'PmemTgQHagk', 'jnG9zog4NCs', '112604', '202431', '6-0bcijTR8k', '97992', 'aE-X_QdDaqQ', 'aiUq5xksJy0', 'nw6Kf3AtCz4', '88S1BjwMfdw', 'rC7qKZMKa0U', 'werKCgZ5dFE', 'ku-dtUqCm2o', 'HxyfY7hsjOg', '15Wu4U2VPLw', '-THoVjtIkeU', '8YsIvz4qnk4', 's2oX3zxWuEI', 'jlW4Iep4mmE', 'xZ1FrxU6hcg', 'SNBqe_JpZC4', 'JYsAacFmXEo', 'dcUlt6zk_S0', 'A6R6J8SJtBc', '243341', '-wMB_hJL-3o', 'CBYQDIqucxE', '7SsmaZZ7mz0', '6zjv1TLqfF0', 'ak7N0BqMluI', 'Kep_mLLXsqk', 'gjGL6YY6oMs', 'faMq0C_wTpU', 'mgovo8VYtvk', '238100', 'cS3BDGNDu_8', 'FCMbWx2JpZ0', '72017', 'cHrOisasWLU', 'Ceu9AkIjuLY', 'lWXjdWvB0VI', 'fi7g4GoK-z4', '_qVgNLJCYdA', '96o9hxy64wI', 'IsAtAzltJNM', '8qCNtqjygW8', 'RXcI6PK37lM', 'XQOUZhWI1B0', '9cxlcpbmrH0', 'qkWdc-E6jGI', 'UeOIb6s0pVM', 'pnSRLB6anIM', '213619', 'G_M3lYn6hAA', 'JP95Fby6qLE', 'n7K5SpMrQt0', 'esR-tOjT6KM', 'ZtuTCuh9C1M', '-a55Q6RWvTA', 'v73dbqOUoXQ', 'qpht9L3s9G4', '5HjbZAbB-Lg', 'QOxIdbNwpx0', '_UNQDdiAbWI', 'OGXUtVG0Y9w', '76sN4tvbPGk', 'O_fTDhCtAhw', 'DhXBaBOB4E8', 'jjb1cWmkhI8', '92221', 'oPvUDLhTrjI', 'G8aL3bM39co', 'DXQGngge7vU', '6G8JJ69aN6o', 'gvjQ1XfMA_g', '7vJy1zbopJ8', 'ySfHPyaDbqY', 'xUz5cCA-oTo', '6hp1SGhVYfY', 'b1Il3Nf6BrU', 'QJCDZCllSYQ', 'P0WaXnH37uI', 'JSlTJsUulH0', 'S0ecaAi_CJo', 'wz3nVBPVgIA', 'TBCjKGYBNIo', '2-EJz4RG4g4', 'AsrhHuCfvF4', 'qJh6x4wmmh8', '6c7vAwDSVGc', 'puum3vabpb4', '255852', 'WANirpnKa4w', 'mjQfQx2K__8', '207812', 'mjYeEikLR8I', 'Y4izAQYtGEw', 'wHQYmMZzyJY', 'hyazktfsZew', '2qKajMu7Vhc', 'lp9vkkimXqg', 'JHW3nD6flgU', 'll10nEjTvGE', 'LL02UFLfQKo', 'HhpziYYP2Vg', '46618', '5wpCKY2U1NE', 'MWCNzYUCys0', 'zg-ZIxVsBbQ', 'YWjTWl0oNLk', '-UuX1xuaiiE', '1dWsw38VDjY', 'yKdIZR5xfcc', '7pZPQbMKGkY', '48BD8qjClfE', 'a5CSKvCAhbs', 'y1gL_MuokI8', '5sDBK-lP8Pg', 'nQ7txb1MtG0', '4Ry6M_ZfJQc', '240915', '69707', '1W38PnuWIkM', 'juI9KoLA87A', 'JcmqmLaL_MQ', 'f47bnEUrOvA', 'mkkoJ2iVbGs', 'j9mRv472dq0', 'Iz_PDdyXr-8', 'aKPfbyW-Qxw', 'F2M7WbPXRps', 'srbrWyZRMCI', 'Uc-0G7RRxoY', 'jPGDFrQLD4I', 'bQcJVJcpgAs', 'Hkt_kncJGVM', '88oSn21TFcA', 'N4WOBzpZtWM', 'QP2CjKap818', 'p4IeTRNcxc4', 'Dq7V30WhOJQ', '56276', 'wMggOhhVouA', 'gFAOKuqpUq4', '6MYUY5tC2Us', 'XblL7mcdDdg', '112903', '49358', 'HjLpXXFoAQw', '5tV5rZZJDCE', 'KJyz9fCt7Is', 'UmB5c_QqUPs', 'HQ9NnDQcxD4', 'JGEEA_JVriE', '7CLe7PZtna4', '56006', '112169', 'S2znq3iRPwE', 'zuc7vUhZNfY', 'ddix4XuaUlY', 'SI39azgVUR8', '9tX18DNC74w', 'Q5fZk_jPjBI', 'EULEL3QhKD0', '25271', 'eJwZfdtlks8', 'MsjnLoTKAXo', 'BLFUj7_uy_0', 'oANUXY3xXKM', 'F59hwsm4Ld0', '33312', 'EJT25p7JahU', 'D5cQWqYcBAE', 'guRD0zQC6Q0', 'e0hYEr848TE', '2Zx4huY-KN8', 'hASTLbFHrEs', 'dEXSb0CfodU', 'rB6WmWvvyxg', '34346', '76124', '3fhCxePBuZY', 'uXYAfpQUYVE', '24202', '2-5hH_k2VFk', 'URP2YlSNuZ4', 'bBJ0BxmIocQ', '8wdxczYf1jI', '5hXC8JbiLd8', 'dZolFNqR-hA', 'PRZ4VhESz1A', '256174', 'Dnhxm6sHQpc', '83310', '-mJ2ud6oKI8', 'pU-MjERGTUk', 'tv8IhQZQuJI', '_t8ETpf2LnM', 'BBoe8-HWPSw', 'U2Ydtq6qvL0', 'BNaRO9g8ugQ', 'iYtD_ArCdKw', 'ELtbrO8FbuI', 'S21ApRNQ9Ko', 'hlBOP5NskhM', 'pwj9YeMJC08', 'FRKwvmrwrZA', 'cKldvZeyRDA', 'EK2bnbzmJs4', 'c6wuh0NRG1s', 'pY4ovojS4rk', 'zknhrUs7-lI', 'slLRsFFiiRc', 'OJwO6g01qO8', 'dOSyvhYsfFo', 'K5cGfs3i-tk', '212532', '-mqbVkbCndg', '0mXv97u2OCM', 'KmYG8zaRmOA', 'hUBQrLjm4M4', 'aWwjhcYLbRw', 'lksy-At0vxc', 'rEWQW_ibDwg', 'E05bA058vts', '3sUS8vXbRwg', 'EiG3r8hAVeY', 'zR-kKDaSDmE', '201582', 'z7FicxE_pMU', 'badtXoOJaf8', '130448', '262165', 'UfLMdSGGQVw', 'HAid0IEUoFQ', '0tkWa2skSmA', 'u6H0sVuY1ac', 'FGnHDWGYsA8', '3y2YInNUmHY', 'kz7ahNfXFsk', '9f6A3ucYArQ', '244829', 'FaHosBIr0xY', '_YzIvwvyIq4', '96350', 'bh4_Kd4hhd4', 'Op3CnqRLD9w', 'Ja7phs8EbWk', 'WygyVNL_qdE', 'aqmRPNfeOy8', 'Vx8npmcFxak', '0AkGtPzl7D8', 'gcpsSao7kHM', '8f_lBxZgDb0', 'Jg2okZn6Ut8', 'DtwbwyfajnI', 'cKUPgzZu-Fk', '8EHEEXex5D8', 'wLj_gnNON7A', 'zFTuwjr3xq0', '96179', 'eZVcshSUD3Q', 'gXDRWhJbfFU', 'w-PFjo89Dpw', 'jqKzaEniiKo', '9ceYD_OzPz8', '52068', 'k4T6GaDrcjs', '8aZbX-xMdgI', 'hF6kFQPdBjY', 'olVQZV_1rdA', 'IHv_yBn83P8', 'Yn8vNC41UMg', 'ARNWtLCbfW4', '128258', '1J9Fa995Ojs', '2iukwQJjGHE', 'oOhxCwkZsUI', 'XcHLB-qfv5M', 'CQnwOZRgQXs', '5IhAgV0Bf_4', 'pC0zFF8CXXk', 'bkP-BNW4oMg', 'dQ56b0bqmc8', 'aiJg0jtIHOM', 'MIuJDn_0yVU', 'O2CEvvYWWbU', '6qmReTSoz0E', '37459', 'P4qxfjZlIrY', '9Nhoi1jfDbY', 'eYCiRWf2NHE', 'QzdEjKQFisQ', '5RVF_3YBUVI', 'uWW1ejwFURI', 'RwcTz-tOIeo', 'gJdSxPhf85M', 'JDgqyOkzXHw', 'OKSx1zxHGpQ', 'c9jD33baJ60', 'ZZzdvUdOTww', '9dFEGb_RfwE', 'BaX10vbFhuU', '8xfW_azeNPk', 'cMsTvqU_-rc', 'gU7McujYYPY', '0bsTzavb-AE', '4Kh5N9W-Jr4', '48u68AzcWvE', '3sDL7mwosP0', '0DBfvvIVmqY', '_HabvL0VnrQ', '139006', 'GxcOSmJAyYQ', 'HXuRR2eBHHQ', 'rvQ2cRnroOU', 'snVkfJKvjwk', 'ixQbCXLUUj8', 'o63doZKEIds', 'HIsJqphLCyw', 'NzpymNJaFjo', 'LpbSYaPRTqI', 'E0g6nae4Ae4', 'ngp7s5Wvde0', 'nAhn8-kZpM8', 'ALlKbGE6BH0', 'yBGuxyO-ElM', 'zOHZDq2BvGo', 'vCWpKubBbcw', 'hfVXx8hfKak', 'P3QEOJWxXI8', 'WUeSV0Z23Kg', 'H9zVQlzit8Y', 'raQ9Pcgo-II', 'aE7sckIAWuw', 'oVqBUyKvgdU', 'hnSdAbnHDy4', '188122', 'YAYfMkxhRiQ', 'Na6170hd8po', 'F8KE2ZhoUe4', 'ZjsQqd6KZIg', 'SZRxuS6fn9s', 'nD1R4UedEDo', 'nGah7qST1dI', 'TSDC7CCyeGY', '0OC3wf9x3zQ', 'v1GKBjohgHc', 'v9GshyXtiWg', 'EO_SN04Xef0', 'O3whFU2lAAk', 'kPn-t6NSxfQ', 'XFJQJb0yaKY', 'aXla94xd_AQ', '79644', '91y7nPEWdmQ', '4WTVL5bNybU', 'yp6Gd2NPwOU', 'vM9AH4EqCaA', '0YdYFtVdlWE', 'd0QNH2vcDgU', '89747', 'FHlzZ2VxuGQ', 'CbQxC1iPyS8', '2ahFSMFvs_c', '227426', 'J_DtcW86D9c', '194625', '4AQC7_uCuEE', '267255', '267252', 'cHBRDdSXLtU', 'PoKZEKOf1dA', 'eMa6gbD7id0', '268836', 'r4ul1wl_1T8', 'zsRTbbKlsEg', 'kqXpf26EL-s', 'g8NBNtY3cpU', 'iH04VOkbof0', 'uy9MGhVqCp8', '39lcRCFvV-s', 'PtdK-TLOuD0', '120vnZnmhq4', 'qCUg4ek1PPE', 'E7ZLz3tSwNM', '6_k3cw9_k-Y', 'mrQIrm6hYMQ', 'zJWmmDk9fCE', '-WXXTNIJcVM', 'HfLVQZLvcH8', 'FMW6diQ9rMo', 'LHC7ZKJy4Zw', 'd3I7Ug-_3L0', 'YEOU4KFDjZo', 'xYtNgq9eTlg', '250430', 'cl1DNRGX578', 'sWsDAG6x9n0', 'Qe4AT670hq4', 'Q7OvlYjNt9w', 'fEm9AdLNrjk', 'L1gXZVU6AE4', 'Gv0kKbfwPpI', '273171', 'GcfETVXgtg0', 'tXxf6-CilNI', '0Svu5BldR5A', '7ZzbemE4QEE', '96361', 'R9ypacCuEZo', 'jFpRdhl3fgw', '_BXmhCPTQmA', 'yxZydS2qHzs', '94215', 'ZSBoSJaD2tQ', 'Emjv2cDzW1E', 'S9PDgK7fpJI', '-HwX2H8Z4hY', 'VCIe-4p0xoM', 'pKXaKinzTmY', '55T4QNcdpOk', 'nF0AMbTH4VM', 'ExDLNkDVsxY', '1mHjMNZZvFo', '0AA-wmk8WdA', 'GCOFujDHDx0', 'ZJGzEeDXbyM', 'lUNNDDsm7R8', '0W4WsjhDgUI', 'LKAEv8x9jKI', 'TFKgo5JlPro', 'D02PT0bl88A', 'qtI3CB1jslQ', '1x7kf9vArjU', 'R8leu0tEJ4o', 'RaTQZrdICKo', '_v8c7iWkYz0', 'OHWyYVux-yw', 'IAubgwEiCcY', 'ZRic9ygn9f8', 'bD0FqMn1KXw', 'zeQKU2L173M', 'I3SPlbTGuNc', '15ktF-6wutk', 'NOl0v54DaXo', 'NKindd5Xn3s', 'RgubFcmvgDE', '9-EO2oCAGA4', 'TwTLsgfpKvA', 'xqcqieV0Rn8', 'dWfgSGnd9zM', 'DatH-ra0VKY', 'F4OhXQTMOEc', 'aYdMtEO0cbI', 'zU2_X9lIcUM', 'FcAgbLF6__s', 'uAExKaLeOl8', 'eaXDCknxPrU', '140317', 'iO34hER47xA', '-t217m2on-s', 'qmx0nQZYHIo', 'amem5EmRG3s', 'J3JU1zBQ4RM', 'mn8_HvzbN5c', 'VWik5oKP6IU', 'OBaMn1-x7jQ', '294178', 'j4MpQ6CKoDE', 'YRbtXb9fWmI', 't-wXEPHHtME', '9VZ4cpoTFbo', '84133', 'HVksxaUzv9Y', 'laxadgca3Fo', 'MTU_thei3-c', 'ihuGFUrzD30', 'jD3iIEsc_K4', '18JTkk8JbeU', 'qJZlp9uxoTU', 'WtiBpLt2wuA', 'TUY83eDK5jc', 'R5a3TP-l_n4', '45676', 'iFGoQUh81as', '236399', 'sjoArVtU8-o', 'bhFK-xy76U4', 'bdtwQxwySN0', 'f6S2XNPIiFk', '0hCihQ5Kep0', 'kDyK9VGfLW8', '36o2cux9kfQ', 'Ea_Huc2-lwo', 'wj4snKbUWZA', 'kKMfsWrigTE', '139032', 'WXKgBIiP8IA', '87400', '21Kxt5L9OBE', 'XAgD-xoil40', 's1tVE8g6JBc', '112148', '3VsrcbjPwZY', 'cUm0TN3vXRc', 'aCwLQrJz4Bo', 'Zj_4YmbMWtg', '233389', 'YGeVGXXK3ao', 'BmDybDBTe7o', 'xk4C4p5vHDk', '13JpsLvddoY', 'ueCWy7aTmyo', 'WZVfvgTeFPo', 'ygb8Cfxghbs', '4jTUcNlxlYA', 'MSmTFZ_-THM', 'F9NruwaEmA8', 'FsmNLTdE2p0', 'CvW0Mh1EWFA', 'XgT2WWcXip4', 'FR0B64ID-hA', 's0PUurm1ONo', 'maO6KmmgcB8', 'nISNBD3I95A', 'W53uRqITk2I', 'u8ViR4L2cVk', '229090', '24xayGF5yYA', 'YqHEmUKUy-E', 'wCtZdAdoIm8', '-dxfTGcXJoc', 'H4RysMUSQD8', '6qPjYvdZiLA', 'ePtlUYCdrNM', 'DVvJoMt9o80', 'h4LrwMn94ss', 'wdU-0bttAkc', 'luQfWSfb1s0', 'atxoi7pB5TM', '48nifdN2vSI', 'RRKez9BR-94', 'kk4gr5A6_Uw', 'J7UduuBfnrE', 'R-17BoOk4kc', '5YnYGjrhzF4', 'DfTMoqwMHVE', '8P0zm2oYDyY', 'b8xmgi4VV0M', 'Xe-keAcLge0', '131936', 'DZBpdzrMelA', 'T-8TvJcS78w', 'QI-TTqj0KnA', 'BB_VwJSg3AI', 'STeqtJLakQQ', 'C-UUQju3bXo', 'HuIKyKkEL0Q', 'NkbRuTJaj_M', 'Fmwc7wkIc4Q', '59333', 'VbmSzYg_lmg', 'pI5Kng_GuLE', '21638', '1pvK0_9SQns', 'CfWxp5bRt2A', 'mO4H5S_Q7aU', '91276']
standard_test_fold=['7l3BNtSE0xc', 'dZFV0lyedX4', '286943', '126872', 'qgC8_emxSIU', 'kld9r0iFkWM', 'rC29Qub0U7A', '4YfyP0uIqw0', 'FMenDv3y8jc', '4wLP4elp1uM', 'KYQTwFVBzME', '27v7Blr0vjw', 'DnBHq5I52LM', 'HR18U0yAlTc', 'x266rUJQC_8', 'd1CDP6sMuLA', 'xSCvspXYU9k', '4EDblUpJieU', '4o4ilPK9rl8', '53609', 'SZ7HK5ns6mE', '243981', 'ySblgk7T7eQ', 'MYEyQUpMe3k', 'EujJ0SwiCRE', '3HyAaqre_Fk', 'iQDB_OkAQWs', 'gE7kUqMqQ9g', 'eFV7iFPYZB4', 'IRSxo_XXArg', '3hOlJf_JQDs', 'BRSyH6yfDLk', '1jogeKX0wGw', '3At-BKm9eYk', 'NVLPURuAVLU', 'pZye4zFzk3o', 'l1jW3OMXUzs', 'XKyumlBmix8', 'eKQKEi2-0Ws', 'WgI8IbJtXHw', 'tnWmVXZ87h0', 'YCEllKyaCrc', 'W1CWpktWtTs', '8wQhzezNcUY', '0bxhZ-LIfZY', 'lrjm6F3JJgg', 'Vdf1McvE9ao', 'eQc5uI7FKCU', '2QXHdu2zlQY', 'YCI-ZzclIPQ', '2Ky9DBSl49w', 'SKTyBOhDX6U', 'b86B3hP8ARM', '23656', 'kpS4BXif_Sw', 'dR68gbeOWOc', 'tC2KicUHB9Q', 'absh1hsZeF0', 'c5zxqITn3ZM', 'uogwnZGb-iE', '46495', 'Sq6DIhFxPqQ', 'PexNiFbPTYM', 'z441aDJvAcU', 'OORklkFql3k', 'WbtsuXkaGeg', 'grsV1YN1z5s', 'Gc_zIjqqUys', '424SXFTCFsA', 'P17tYiqMGRU', 'UweZVaFqruU', 'mzAu5gxjE-w', '8TDAP0KNIIw', 'u9ZV8jb_-U0', 'iPPp6MCythU', 'lwL4hjhkid4', '102389', 'frCWtiam4tE', 'pSxte-ms0t8', 'c9hE1ghElrM', 'WfNiQBXmPw8', '_q7DM8WkzAQ', '257534', 'fU5AYkq0m9k', 'q17gSr9kNww', 'AgH84SNRx5s', '206585', 'yzCHa2qchpg', 'GmpDbIstUdc', 'eREud0qYR3s', 'NoOt0oU843M', 'svsbGQn389o', 'ZsLrKF7_Oos', 'Kyz32PTyP4I', '7idU7rR77Ss', '8lfS97s2AKc', 'X2Hs89fZ2-c', '5vwXp27bCLw', 'tZDNinnrGf8', 'KB5hSnV1emg', 'TxRtSItpGMo', 'eJfT7-dDqzA', 'x2n19Cn96aw', 'XDVit9ASVUg', '6brtMLkjjYk', '-rxZxtG0xmY', 'JATMzuV6sUE', 'LueQT0vY1zI', '267466', 'm-7yRWZLwLY', 'OWWHjP3pX9o', 'QnYlpSeVOYo', 'V7OFSHYcQD0', 'GK-Pprzh0t0', 'yLo-Jl8nBXU', '200941', '61531', 'ezuWKsxPRSM', 'ehZrOdw6PhA', '-6rXp3zJ3kc', 'Z4iYSMMMycQ', 'MtIklGnIMGo', '116213', '3XShFTBsp_Q', 'YQZPnHZRp1w', 'fsd1qPLA3kY', '208322', 'uVM4JWjfGgQ', 'QWll4lS1qqI', 'Vlas-mPydcg', 'teQqaAmqqx0', 'AQ4Pktv4-Gc', 'yCpHmPSshKY', 'pDRdCSIyjkA', 'sIusv36VoBY', '8jY_RhOS89o', 'GKsjv42t284', 'HA2AiTz-qxc', 'GXIfrEUJ5d4', '0Fqav67TDEw', '10219', 'wHeZHLv9wGI', 'qDfSYz0PX9g', '180971', 'qBanrqkzobg', 'NgENhhXf0LE', 'SH0OYx3fR7s', 'lc5bSoGlQwY', 'XrNaL-MTjXg', '8i7u3fl-hP8', 'N-NnCI6U52c', 'r46amqjpWgg', 'QVyxySAaehE', 'JKueLneBoik', '110565', 'TqQgIxR7thU', '267694', 'ZKErPftd--w', 'GMa0cIAltnw', 'MSHBEntSDjU', 'AB1PbMaW03s', 'oBS-IW-BO00', '5fKPJPFqPho', '8NPaDkOiXw4', '104741', '2ItiGjefTRA', 'LFOwCSiGOvw', 'YLK58srjhNI', '233939', '5xa0Ac2krGs', 'CbRexsp1HKw', '112425', 'bCBMKwafZKY', '_0efYOjQYRc', 'O2ShYliS3CU', 'Oa2xVjzAMFc', 'bnzVR2ETQQ8', 'yBtMwyQFXwA', 'TtAyUQtmTLk', 'yXE_XZUb8qE', '3wHE78v9zr4', 'cml9rShionM', 'rePYTlT5_AY', '9TAGpMywQyE', 'ryE9VBiR3p8', '238063', 'NlrCjfHELLE', 'oGFDE-6nd7Q', 'bWmrrWQOVCM', '29751', '11UtTaDYgII', 'jZe-2w7pkd8', '275267', 'tymso_pAxhk', 'PcqKFt1p3UQ', 'sfaWfZ2-4c0', 'kLAXmTx2xOA', '3OYY5Tsz_2k', 'wk5lFk5kFjY', 'hE-sA5umuCk', '3IUVpwx23cY', '92291', '102213', '236442', 'nbru7qLot04', 'zhNksSReaQk', '8VhVf0TbjDA', '35694', '20LfN8ENbhM', '257277', 'VsXGwSZazwA', 'EyoMU2yoJPY', 'E1r0FrFyNTw', 'CO2YoTZbUr0', 'wC_1M7KIv9s', '24196', '194299', 'R9xTBw3MCWI', 'cY8DcaHXNNs', 'SwT0gh0V8fI', 'UiurP5k-f1A', 'N0d2JL7JC1s', '208592', 'GAVpYuhMZAw', 'pvIQWWiT4-0', 'namehdJxRIM', 'tNd3--lvSXE', 'NaWmaHwjElo', 'mfpR4CN9LZo', 'U6IqFbpM-VM', 'XLjpZUsFEXo', 'YUNxD04EvfE', 'hI7ObFqn9Bg', 'CO6n-skQJss', 'RsE2gYghZ2s', '2ze94yo2aPo', '254427', 'MHyW857u_X8', 'Xa086gxLJ3Y', 'Uu_XyXyKHAk', 'TsfyeZ8hgwE', 'vI5JH0daNsM', 'mmg_eTDHjkk', 'lD4xtQ6NpDY', 'XWIp0zH3qDM', '259470', '0eTibWQdO5M', 'fcxbB7ybUfs', '5pxFqJ5hKMU', '245582', 'WQFRctNL8AA', '2m58ShI1QSI', 'cn0WZ8-0Z1Y', '25640', 'huzEsVEJPaY', 'UTErYLpdAY0', 'F2hc2FLOdhI', 'vGxqVh_kJdo', 'F_YaG_pvZrA', 'UNLD7eYPzfQ', '0K7dCp80n9c', 'xBE9YWYGjtk', 'nTZSH0EwpnY', 'mZ_8em_-CGc', 'fdc7iyzKvFQ', '221137', 'QBc7X5jj8oA', 'pnpFPX34Agk', '63951', 'veA6ECsGFxI', 'XbkYA-iXUwA', '1LkYxsqRPZM', 'qAip3lZRj-g', 'gR3igiwaeyc', 'pIaEcqnzI-s', 'oHff2W51wZ8', 'XlTYSOaZ_vM', '3WZ6R9B0PcU', 'IOpWjKAHG8Q', '53766', '190743', '107585', 'SYQ_zv8dWng', 'hBzw4r0kfjA', '0uftSGdwo0Q', 'jj8aSNPHMw8', '86c2OkQ3_U8', 'rhQB8e999-Q', 'qyqVc352g3Q', '1zXAYdPdzy8', 'nZFPKP9kBkw', 'A1lFJXUpxZo', '-cEhr0cQcDM', 'Kn5eKHlPD0k', '255408', 'eD5cScqaf6c', 'FHDVQkU-nGI', '24351', 'NOGhjdK-rDI', 'fz-MzQcOBwQ', 'DjcZrtcBZi4', '1HS2HcN2LDo', '209758', '2o2ljA0QD7g', '211875', '5lrDS7LluCA', 'ybK5wRaaUyE', 'M6HKUzJNlsE', 'QIonRUsCqBs', 'k8yDywC4gt8', 'jPtaz1rN6lc', '69824', 'kI6jzM_aLGs', 'x8UZQkN52o4', 'ZKZ8UjaQQT4', 'obGF3RfWQKE', '221153', 'YgyeyooSz0g', 'faUvT7zfsyk', 'ddWHTdJz2O8', 'OKJPFisBoPY', 'HAnQVHOd3hg', 'EO_5o9Gup6g', 'F7zQPzwFToE', '273250', '1pl2FVdQWj0', '91844', 'bvycs3BXtx0', 'hbJfSyJKBEA', 'ZHUFlEgKk-w', 'OyK86reBnJE', 'xwvSYhQrHoA', 'H-74k5vclCU', 'Sb6ftNgzz9M', 'Hq3cHc6X8BM', 'jscKL5jS-SQ', '2vsgDSlJ9pU', 'DtbT85s3i94', 'LcfubBagG6Q', 'f-VdKweez2U', 'a8UMRrUjavI', 'MvEw24PU2Ac', 'MZUr1DfYNNw', 'UcV-bpksJi0', '2W-U94hXuK0', 'OctOcfI4KSs', 'NocexkPXja8', 'eUwbRLhV1vs', 'bdFCD-3BCRg', 'TXiOSZdaLJ8', 'XadAy93f1P8', '136196', 'gJjkCPO7iXg', '210433', 'oH9fMma8jiQ', 'd-Uw_uZyUys', 'oQizLbmte0c', 'X6N7UEFJLNY', '0PlQc98SccA', '3REPHw7oLWo', 'vB_kZocHtYo', '2BuFtglEcaY', 'HMRqR-P68Ws', 'V27mmEkN80g', 'Y2F51I-dzAg', 'dTcz1am1eUw', 'gL8h7lOPv1Q', 'WoL4fCxGd8Q', '135623', '41381', 'IHp8hd1jm6k', 'dHk--ExZbHs', 'o2XbNJDpOlc', 'V2X1NU5RkwY', '9orb0lQnVW4', 'fsBzpr4k3rY', '2fbBrB1nJEQ', 'um8WVjZMLUc', 'eE8Qr9fOvVA', 'fVCDn6SdtVM', '83400', 'an_GzG40hcE', 'xkEK17UUyi4', 'y3r2kk8zvl0', 'KanWhGY33Hk', '210259', 'DR65no1jCbg', 'lkIe41StoGI', 'RB3HA-ZMtFw', 'qEuJj4uW93E', 'ydzNAuqUAnc', 'GO0V4ZGSF28', '9PzZSheh10U', '6RFVsOWK1m4', '-s9qJ7ATP7w', 'ey1lr8wFFDc', 'oZxMx8e0x2U', 'UjqA6KVW2m8', 'OaWYjsS02fk', '79356', '34cU3HO_hEA', 'KZzFCrEyKF0', 'c5VEvmutmVg', 'O4UkHVJlIs8', '22373', 'v_8QeoNc4QY', 'BR2pkk3TK-0', 'EMS14J0odIE', '221274', '92496', 'DMtFQjrY7Hg', 'h1ZZHUU4j0k', 'gpn71-aKWwQ', 'tW5xAWDnbGU', '88791', 'vJDDEuE-FlY', 'kaudsLIvYC8', 'x0rLwBIocuI', 'wnL3ld9bM2o', '8wNr-NQImFg', '37NMbnd7r20', '56989', 'ctAZf4sMBUQ', '7npCA0zoQ8Q', 'u9I5WD3Nglk', 'IIPYcCii7Sg', 'JNhqI4JtPXA', 'Bpy61RdLAvo', 'C5-cY1nPQ20', 'ihPjsliqz5o', '4t5k_yILGJM', 'mgsvwAVQAQo', 'Ie6sDptjAsU', 'lkeVfgI0eEk', 'O-b3DQg0QmA', 'PzI6yY9Y2xQ', 'lYwgLa4R5XQ', 'NIpuKcoJhGM', 'LpTbjgELALo', '0YiAKqU36KE', 'ZznoGQVwTtw', 'QCR7uyowjhM', 'ossKC1VrusE', 'p4WmcxrXkc4', 'ZS1Nb0OWYNE', 'P0UHzR4CmYg', 'qTkazqluJ_I', '252097', '0JaYazphxfM', 'zvZd3V5D5Ik', '-RfYyzHpjk4', 'l0vCKpk6Aes', 'ktblaVOnFVE', 'KRje7su4I5U', 'FqEekswKPWE', '130366', 'HFPGeaEPy9o', '-HeZS2-Prhc', '93iGT5oueTA', 'L-7oRnbi9-w', 'pQpy7RSfWzM', 'YsMM_1R1vtw', 'SBFnCNzlynQ', '4dAYMzRyndc', 'CU6U-gS76K4', 'NiAjz4ciA60', '-9y-fZ3swSY', 'LD3HYOwk1Bc', 'QXXexH-ow_k', '-UUCSKoHeMA', 'RVC8l5hf2Eg', '89ZmOPOilu4', 'xobMRm5Vs44', 'xmLJHru6Z1M', 'zfZUOvZZTuk', 'LJGL2sGvSS0', 'Pbu6oAKFCvo', 'nFTo-Lz4Fr8', 'CwF97vXPYX4', 'WJM8u2I2rQ4', '8XZszYrUSCQ', 'fT6SrlsWV7M', 'fWAKek8jA5M', 'jXQmVFcOiUI', 'KrmVX-HANew', 'kXhJ3hHK9hQ', 'oPlnhc0DkcU', 'OFia3dWgaoI', 'VVtx4IDsHZA', 'VIVkYG31Oas', 'I9iV9q3ePhI', 'ZeH7gZw94k0', 'wznRBN1fWj4', '226601', 'TcTGCIh6e5s', '1S6ji_d4OLI', 'mRqqH_gx7Q0', 'Zb7bdrjWyEY', 'VDkBM0ZG4q8', 'BJS5KCSowgU', '3UOqbf_B_Yc', 'LyOq9mOEPuk', '-MeTTeMJBNc', 'QLI-OnegxFM', '3odZe3AGilc', 'VXy21GwGs8o', '7deoh0NoMs4', 'DzdPl68gV5o', 'VS7xSvno7NA', 'H_x5O9GdknI', '67uKYi7mslE', 'Kn99u05vlpA', 'gKojBrXHhUc', 'AHiA9hohKr8', 'kmgsC68hIL8', 'XVWiAArXYpE', 'X_TusmBIlC0', 'dlE05KC95uk', 'KXsjl0DKgL0', 'b92iw0OAnI4', 'j1m6ctAgjsM', '6EDoVEm16fU', 'jE3gYsxr_5s', '6EJHA6IDLNk', 'xXXcgb9eZ9Y', 'rcfnqiD0y8o', '224370', '237363', '7IxmlIwqigw', '6gtfeIqGasE', '9GzFQBljNIY', 'vGkIaClHKDg', 'iXiMifHNKPI', 'BTjV5dU_rfY', 'g6VJg6ycUk0', 'Y8dI1GTWCk4', 'y5Jpf48SUX8', 'iFxFTtCQ6zA', 'ZKKNd0zR8Io', 'U8VYG_g6yVE', 'GNP0PFas12Y', 'ussfmzwftQ8', 'jLN6B0aSrW0', 'OXsTIPdytiw', '121400', 'CKqDDh50gcU', 'HJTxq72GuMs', '273207', 'lxBKEPIUSgc', '234046', '59673', 'USkMa4Evv7U', '213327', 'kXiBdruxTvE', '201005', '94481', 'ChhZna-aBK4', 'a4PHWxILDp0', 'SqAiJrvHXNA', 'kg-W6-hP2Do', '9Lr4i7bIB6w', 'fhADeWE5VgU', '-yRb-Jum7EQ', 'DVAY-u_cJWU', 'wd8VQ5E7o7o', 'N2nCB34Am-E', 'f8Puta8k8fU', '272838', 'Qfa1fY_07bQ', 'WBA79Q3e_PU', 'ozA7pRW4gFM', 'WuaoxGAKue0', '-AUZQgSxyPQ', 'l4oMbKDuW3Y', '198112', 'H9BNzzxlscA', '224631', '111881', 'U-KihZeIfKI', 'JXYot3NDQn0', '7f3ndBCx_JE', 'F8eQI8E-6q4', '112509', '46615', 'p1zqEGwRMI8', 'Wu-wQTmxRgo', 'V0SvSPkiJUY', '28006', 'cia8OM3Oe7Q', '_aJghSQmxD8', '97ENTofrmNo', '252912', 'bkX5FOX22Tw', '108146', 'Iemw8vqt-54', 'vTAV6FThy30', '_WA0HtVEe8U', '132028', 'nXWNHVZtV9A', 'MLegxOZBGUc', '224263', 'q5M1God4M6Y', '9cYNT_YSo8o', '22689', 'SD6wphlw72U', 'SqofxdeEcjg', '_on_E-ZWy0I', '222247', 'cX8FScpsfLE', 'k1BrzX5bc7U', 'Rb1uzHNcYcA', 'RChkXDS8ulE', '7mb8Y2AhXIY', '226640', 'MM2qPdnRmQ8', 'unOeTDc2rlY', 'ROC2YI3tDsk', 'AlJX3Jw3xKk', 'MHVrwCEWLPI', 'bNQOeiAotbk', 'TLPlduck5II', 'An8x4UfwZ7k', 'JHJOK6cdW-0', 'xU3N7ujUB-g', 'RvmTZVNAAuQ', 'LtlL-03S79Q', 'Xy57UpKRNEo', 'lO6N9dyvPTA', 'cW-aX4dPVfk', 'VwGPIUNayKM', 'p7zuPEZgtY4', 'ZtocGyL3Tfc', '24504', '5eY4S1F62Z4', 'ttfaZ8IIWCo', 'z0y1ZxH1f74', 'VLQgw-88v4Q', '1Gp4l-ZTCVk', 'QJBQIOmG1CA', 'jqutn5ou8_0', 'gcFECfN4BCU', 'Dm8AL84e11w', 'tO68uTk-T_E', '215318', 'DlX-WyVe-D0', 'gLTxaEcx41E', 'RmX9t_HY_dU', 'HbaycY0VuZk', 'dxsPkcG-Q30', 'ZcFzcd4ZoMg', 'yUqNp-poh9M', 'yoDMh8FlHR8', '167521', 'kbRtSmJM5aU', 'skRqBxLLJkE', '100178', '-ri04Z7vwnc', 'mVnqP-vLpuo', 'B9oeT0K92wU', '_OmWVs0-6UM', 'DebbnL-_rnI', 'GlShH_ua_GU', 'Jz1oMq6l-ZM', 'L-a4Sh6iAcw', 'LDKWr94J0wM', 'aa0J1AXSseY', '173CpFb3clw', '202826', 'Wmhif6hmPTQ', '283935', 'naZi9AusrW4', 'wO8fUOC4OSE', '_1nvuNk7EFY', 'PHZIx22aFhU', 'ex-dKshlXoY', '6uoM8-9d0zA', 'ahG9c_uaf8s', 'vR90Pdx9wxs']
standard_valid_fold=['188343', 'VAXhC2U9-2A', 'AxNy9TeTLq8', 'EmmuWoCUgXs', 'icbUzboLcDQ', 'KkKWFZZmmCM', '2Xt31_d0XEE', 'uooIiW6dEyg', 'JAnRCQ9A0vI', 'NzvNW7vP-Co', 'Zvisaa77Cng', 'JOK1SSmPtFw', 'Y7h-S3cJ52o', '_gr7o5ynhnw', '70280', 'ZaoFHcbRM9g', '258654', '--qXJuDtHPw', 'RArhIHk4Qs4', 'TWszOxkOV0w', 'K8gp7ncdUl8', 'uacdDoBtT1k', 'Fy0Uid9afM8', 'r8Jyl2Bfl14', 'UiPmjKggv1s', 'vU0a4F36Ksw', '9QI-9w_VdB4', '6_ZT8beQXq8', 'UvniNGPyeBc', '117tQqLjza4', 'xjsaS-LeZ14', 'zhE_68GMJIk', 'lO87-4Kf0cQ', 'EEjCkc82oyk', '-uywlfIYOS8', 'mjpCK2Edsv8', 'XzVapdEr_GY', '31474', 'x-zGBp7axao', 'TXCXFYIc3Yo', 'SuIcJvERiFk', 'kvUb78Rdzdc', '102858', 'XIGpuL-Kkyk', 'b-FX9NOVQOM', 'ViyQVpGW05w', '0y022OlZ3W0', '3V2qm0rw920', '75RGHaxmUK8', 'YbuG8xyUO-o', 'IRY4D_-mx3Q', 'nyzIL6YAonY', 'PboaYD5hlG8', 'JVpF99zuQhA', '84140', 'Nrurc5sMUOE', '2J4zrDn7K4s', '11j7EfglCAs', 'HGicRLwgtkM', 'OrYBtyO0aPI', 'hqzF4IDaIYE', '76PsKs4kPXE', 'VwvptdTkwEE', 'DdUJojoFU_c', '0utROiKxejc', 'goMtnNHQ_z4', 'y8HXGm1-Ecw', 'c1a1y9ytHH0', '5B0PQx3Ep3k', 'mLW-jn67gRE', 'IUmxJNs2zaY', 'r9tgDqXEcuc', 'Wrcf2xtqbkQ', 'bWunvAd96zI', 'JGzFUzPeAA8', '89835', 'evAswZ6m3hg', '121128', '6hFiTU77Sm0', 'SO53x_pbou8', '32681', 'MoQmPA7Q07Q', 'dBWvtPeHpWM', 'OwE-7MwzfYI', 'Arh2TKRi_mg', 'Q4WzApjaCNI', 'v9gjg7TDlTA', 'vC9oWzTU71s', 'lilHOUfWrIA', 'NoZsdSGnNpI', 'Z7L3V5bwzI0', 'f_ZJ7L14oYQ', 'mHGaQ_nv9UY', 'RzOFxDk26p0', 'nUZYqTRSGDw', 'gR4gM_WXesQ', 'ioupaiAuRr0', 'xivYoEUQ5sk', 'eOiC1kb17P4', '6uPGcKTpC4I', 'jICmfLeFymA', 'MjaaudUc5-4', 'g8Cl74tS3oY', '237009', '50103', 'pVs1daijYTw', 'j0br-fFy160', '243646', '101787', 'Baz0VVQ-E9E', 'qY1sXq-YCHs', 'Pt-D0LUHDSc', '6KvG5VbLalY', '273539', 'K0m1tO3Ybyc', '125344', 'Uc_6d-fkZEc', 'KpMCvUyQCXg', '4dV3slGSc60', 'Qa6Yz62V-Yc', '5kaCGzjYukM', 'iUXqlrui25c', '6ZA8I83x-oY', 'x2lOwQaAn4g', 'vHzbn_YW76s', 'ewBrNsyY82Q', '-UacrmKiTn4', '3j94B0pzSVs', '80855', 'SHa756SwGJQ', 'r5ijC2W9ddk', 'Q7S0tX4FUNA', 'wvLEIxt-_V0', 'bNQkb4K5DX0', 'bAkUEnPoucg', 'b1LEcg6z66g', '96642', 'DlbYiwOnTyk', '8eaYvALnJ0o', 'Ezn3p5FWF_U', '8x_nCOh6Wmc', '5i6AgQSjXO4', 'ooAF6I-fmTg', 'H1DpVwktfDQ', 'fPsy1co_nuw', 'MD6Tq_4VlGc', 'jPrEKz1rAno', 'HmXXW45eZL4', '1HK7Nea0PFo', 'bpvYdXVlgvc', 'qmMSumMloAs', '06st0Ez_E_I', 'AG5EY8ZaFj4', 'eKRWfaizBO0', 'k5ZOshC2LP4', 'MMpo2bDk-DU', 'rojyUp4FPSg', 'AbNmF4RTzOI', 'kfsO4c0Ekes', '5O1W39o56gg', 'zjYEBwXGD8I', 'xUgAP84vsg4', '290546', 'KDjl2exStlI', 'q9yDL81QppI', 'PyQrAYl1bFs', '_BvNNdEkhZA', 'Lh8r-5eHX6Q', 'r91csZc6AXE', '4cFeG2ydm9A', 'E8MuzHUhUHk', 'unNY4zIk8MM', 'zk2jTlAtvSU', 'XaVYxIW0FDg', '128059', 'c5cB7AfVgcE', 'QjcQx8_PQfw', 'tXQpm-nKxNA', '99501', 'sPremsknoLM', 'Es9MkKsMsjU', 'PORCNDRKtko', 'ip8xwAr4MRE', 'QxU625Hn370', '-I_e4mIh0yE', 'F4yFRROWtdE', 'VbV9S4svrTg', '102408', 'ffrJ91swyq0', 'd8BR6hsvzoY', 'v2Rr-EsJda8', '128763', 'rwNlqh0k1j4', 'kbGhEJ4W44o', '70HptJgAhZM', 'rf0yDSeVEUA', 'pRdxEaLB8r4', '2S00zYaVrtc', 'C864zaWmEd0', '33170', 'KB73TD4xQ8Y', 'jrDqduyQrfo', 'XytBlo2R5Yg', 'ssqiwP19JhM', '-qDkUB0GgYY', '247318', '223431', '80566', 'F6JV-K840EY', 'FB_b1dm0SRY', 'wF8980oGklk', 'WmQF5RmbsVQ', '_gzYkdjNvPc', '830KzUc6CbU', 'QpchvHpGFc8', 'vySKXq0ZOb0', 'Y7qkyMyanjU', '241629', 'Viz5vDE39y8', 'CJGuudyvA0Y', 'TYJzg5IJN8o', 'vo_JbAFAD68', 'PwapK9d8IGk', '266791', '216097', 'Gz2qsCqWNUY', 'aFhc2ddipoM', 'Tpdqfpuumg4', '_7HVhnSYX1Y', '270254', 'dEDbm2ubVRQ', '257247', 'R7IkQVUuLew', 'XyP8bVmGX6M', 'r13W4H8ZhqI', '252998', 'WxajvjGKz7Y', '9iRncKVM2PA', 'gVqs4TzqySw', 'u6PL_7Z9QlU', '272624', 'sC16n1k66io', 'ROcTx5VEn7o', 'IM6HW1HwHhM', 'KqFarHUGjSc', 'OLP0nCKwU6k', '125676', 'BSKAHXFYF_I', 'erNDEjQeox8', '3MFNIag0wNE', '7_K3F-lAv1k', '_aZDaIfGfPo', 'bQ8QteHvrEk', 'fWOIAxzBQFY', 'TH32jop4FiI', 'L1eFHRQGFeg', 'vbr3EA8cJTI', 'ly3QDQDJzzQ', 'N5xfBtD6rLY', 'qK77ZmbqmOM', '236021', '225770', 'hrLoOAh_8LY', 'szic2IB9HB4', 'VinxKpWioTo', 'wosolsrH3sM', 'a-WihYDk6vc', 'CPjbogfLHR4', 'bj9e8w4vNxo', 'TqMh7U3J4D4', 'wgca4dZnnVQ', 'y9FyTEyGy5Y', 'F1U26PLiXjM', '-hnBHBN8p5A', 'FxxJB8hBpyQ', 'EQxkXiWAm08', 'DpZGnuj-BA8', 'H6ci6Myq8uI', 'JPT38CA3sGI', 'tQ-CIfgj-Js', '130456', 'ET1cU5_A2YM', 'fe2CWCpdTF8', 'uu1FqsR7JV0', 'UlTJmndbGHM', 'N1X63d_jgmw', 'lWf5hHRHIDs', 'lawHYX5eB20', 'HetCe0lLacc', '7r4vRxKLFCA', '-571d8cVauQ', 'MCsvw5-7lVE', 'H9mSft9YGuk', '112433', 'aK5tRCXjUvU', 'hvfaYsv7p8E', 'RrGpzInAwCg', 'pOrk7fl1AYo', 'dt641WxonBI', 'Vuay0mVKkik']
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/dataset/standard_datasets/CMU_MOSEI/cmu_mosei_std_folds.py |
import sys
from datetime import datetime
from colorama import Fore
from tqdm import tqdm
class bcolors:
HEADER = '\033[95m'
OKBLUE = '\033[94m'
OKGREEN = '\033[92m'
OKPURPLE = '\033[0;35m'
OKADVISORY = '\033[1;36m'
WARNING = '\033[93m'
FAIL = '\033[91m'
ENDC = '\033[0m'
BOLD = '\033[1m'
UNDERLINE = '\033[4m'
def success(msgstring,destination=sys.stdout,verbose=True):
now=datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
if type(destination) is not list:
destination=[destination]
if verbose==False:
return
for dest in destination:
print(bcolors.OKGREEN+bcolors.BOLD+"[%s] | Success | "%now+ bcolors.ENDC+msgstring,file=dest)
def status(msgstring,destination=sys.stdout,verbose=True,end=None,require_input=False):
now=datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
if type(destination) is not list:
destination=[destination]
if verbose==False:
return
input_from_user=None
for dest in destination:
if end is None:
if require_input:
if dest==sys.stdout:
inp_f=raw_input if sys.version_info[0]<3 else input
input_from_user=inp_f(bcolors.OKBLUE +bcolors.BOLD+"[%s] | Input | "%now+bcolors.ENDC + msgstring)
else:
print (bcolors.OKBLUE +bcolors.BOLD+"[%s] | Status | "%now+bcolors.ENDC + msgstring,file=dest)
else:
print (bcolors.OKBLUE +bcolors.BOLD+"[%s] | Status | "%now+bcolors.ENDC + msgstring,file=dest)
else:
print (bcolors.OKBLUE +bcolors.BOLD+"[%s] | Status | "%now+bcolors.ENDC + msgstring,file=dest,end="\r")
if input_from_user!=None:
return input_from_user
def advisory(msgstring,destination=sys.stdout,verbose=True):
now=datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
if type(destination) is not list:
destination=[destination]
if verbose==False:
return
for dest in destination:
print (bcolors.OKADVISORY +bcolors.BOLD+"[%s] | Advise | "%now+bcolors.ENDC + msgstring,file=dest)
advise=advisory
def progress_bar(total,data=None,unit="iters",postfix="",leave=False):
if data is None:
return tqdm(total=total , postfix=postfix,unit=unit, leave=leave)
#TQDM has issue with the formatting and {bar}
#return tqdm(total=total , postfix=postfix,unit=unit, leave=leave,bar_format="%s{l_bar}%s{bar}%s{r_bar}%s" % (Fore.YELLOW,Fore.GREEN,Fore.YELLOW,Fore.RESET))
else:
return tqdm(data, total=total , postfix=postfix,unit=unit, leave=leave)
#return tqdm(data, total=total , postfix=postfix,unit=unit, leave=leave,bar_format="%s{l_bar}%s{bar}%s{r_bar}%s" % (Fore.YELLOW,Fore.GREEN,Fore.YELLOW,Fore.RESET))
def error(msgstring,error=False,errorType=RuntimeError,destination=sys.stdout,verbose=True):
now=datetime.utcnow().strftime('%Y-%m-%d %H:%M:%S.%f')[:-3]
if type(destination) is not list:
destination=[destination]
if verbose==False:
if error:
raise errorType(msgstring)
else:
return
if error:
for dest in destination:
print (bcolors.FAIL +bcolors.BOLD+"[%s] | Error | "%now+bcolors.ENDC + msgstring,file=dest)
raise errorType(msgstring)
else:
for dest in destination:
print (bcolors.WARNING +bcolors.BOLD+"[%s] | Warning | "%now+bcolors.ENDC + msgstring,file=dest)
def warning(msgstring,destination=sys.stdout,verbose=True):
error(msgstring=msgstring,destination=destination,verbose=verbose)
def progress_spinner(message,progress,speed=1./5000):
speed=float(speed)
status ("%s%s"%(message,'/-\|'[int(progress*speed)%4]),end="\r")
spinner=progress_spinner
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/log/log.py |
from .log import *
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/mmsdk/mmdatasdk/log/__init__.py |
#download_dataset.py
#downloads a standard dataset from multicomp servers
import mmsdk
from mmsdk import mmdatasdk
import argparse
parser = argparse.ArgumentParser(description='Downloads a dataset from web')
parser.add_argument('dataset',
metavar='dataset',
default='cmu_mosei',
choices=['cmu_mosei', 'cmu_mosi', 'pom'],
help='download a standard dataset (cmu_mosei,cmu_mosi,pom)')
args = parser.parse_args()
choice={"cmu_mosei":mmdatasdk.cmu_mosei.highlevel,"cmu_mosi":mmdatasdk.cmu_mosi.highlevel,"pom":mmdatasdk.pom.highlevel}
labels={"cmu_mosei":mmdatasdk.cmu_mosei.labels,"cmu_mosi":mmdatasdk.cmu_mosi.labels,"pom":mmdatasdk.pom.labels}
dataset=mmdatasdk.mmdataset(choice[args.dataset],'./downloaded_dataset')
dataset.add_computational_sequences(labels[args.dataset],'./downloaded_dataset')
print ("List of the computational sequences in the downloaded dataset")
print (dataset.computational_sequences.keys())
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/examples/mmdatasdk_examples/basics/download_dataset.py |
print ("Some of the content in this tutorial may be outdated, however it is an amazing tutorial nonetheless: https://github.com/Justin1904/CMU-MultimodalSDK-Tutorials")
print ("Special thanks to Zhun Liu @ justin1904")
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/examples/mmdatasdk_examples/basics/justin_github.py |
#read_dataset_by_folder.py
#reads a dataset from a dataset folder
import mmsdk
from mmsdk import mmdatasdk
import argparse
parser = argparse.ArgumentParser(description='Reading dataset from a folder')
parser.add_argument('path', metavar='path', type=str,
help='the folder path to read dataset from')
args = parser.parse_args()
dataset=mmdatasdk.mmdataset(args.path)
print ("List of the computational sequences")
print (dataset.computational_sequences.keys())
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/examples/mmdatasdk_examples/basics/read_dataset_by_folder.py |
#read_dataset_by_folder.py
#reads a dataset from a dataset folder
import mmsdk
import os
import argparse
from mmsdk import mmdatasdk
from os import listdir
from os.path import isfile, join
parser = argparse.ArgumentParser(description='Reading dataset by files')
parser.add_argument('path', metavar='path', type=str,
help='the folder path to read dataset from')
args = parser.parse_args()
dataset_dictionary={}
if os.path.isdir(args.path) is False:
print ("Folder does not exist ...")
exit(-1)
csdfiles = [f for f in listdir(args.path) if isfile(join(args.path, f)) and f[-4:]=='.csd']
if len(csdfiles)==0:
print("No csd files in the given folder")
exit(-2)
print("%d csd files found"%len(csdfiles))
for csdfile in csdfiles:
dataset_dictionary[csdfile]=os.path.join(args.path,csdfile)
dataset=mmdatasdk.mmdataset(dataset_dictionary)
print ("List of the computational sequences")
print (dataset.computational_sequences.keys())
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/examples/mmdatasdk_examples/basics/read_dataset_by_files.py |
#create_toy_computational_sequence.py
#this example shows how to create two toy computational sequences and put them together in a dataset
import mmsdk
from mmsdk import mmdatasdk
import numpy
def random_init(compseq,feat_dim):
for vid_key in vid_keys:
num_entries=numpy.random.randint(low=5,high=100,size=1)
compseq[vid_key]={}
compseq[vid_key]["features"]=numpy.random.uniform(low=0,high=1,size=[num_entries,feat_dim])
#let's assume each video is one minute, hence 60 seconds.
compseq[vid_key]["intervals"]=numpy.arange(start=0,stop=60+0.000001,step=60./((2*num_entries)-1)).reshape([num_entries,2])
if __name__=="__main__":
vid_keys=["video1","video2","video3","video4","video5","Hello","World","UG3sfZKtCQI"]
#let's assume compseq_1 is some modality with a random feature dimension
compseq_1_data={}
compseq_1_feature_dim=numpy.random.randint(low=20,high=100,size=1)
random_init(compseq_1_data,compseq_1_feature_dim)
compseq_1=mmdatasdk.computational_sequence("my_compseq_1")
compseq_1.setData(compseq_1_data,"my_compseq_1")
#let's assume compseq_1 is some other modality with a random feature dimension
compseq_2_data={}
compseq_2_feature_dim=numpy.random.randint(low=20,high=100,size=1)
random_init(compseq_2_data,compseq_2_feature_dim)
compseq_2=mmdatasdk.computational_sequence("my_compseq_2")
compseq_2.setData(compseq_2_data,"my_compseq_2")
#NOTE: if you don't want to manually input the metdata, set it by creating a metdata key-value dictionary based on mmsdk/mmdatasdk/configurations/metadataconfigs.py
compseq_1.deploy("compseq_1.csd")
compseq_2.deploy("compseq_2.csd")
#now creating a toy dataset from the toy compseqs
mydataset_recipe={"compseq_1":"compseq_1.csd","compseq_2":"compseq_2.csd"}
mydataset=mmdatasdk.mmdataset(mydataset_recipe)
#let's also see if we can align to compseq_1
mydataset.align("compseq_1")
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/examples/mmdatasdk_examples/basics/create_toy_computational_sequence.py |
import mmsdk
from mmsdk import mmdatasdk
from mmsdk.mmdatasdk import log
import numpy
def myavg(intervals,features):
return numpy.average(features,axis=0)
def deploy(in_dataset,destination):
deploy_files={x:x for x in in_dataset.keys()}
in_dataset.deploy(destination,deploy_files)
def download_data():
source={"raw":mmdatasdk.cmu_mosei.raw,"highlevel":mmdatasdk.cmu_mosei.highlevel,"labels":mmdatasdk.cmu_mosei.labels}
cmumosei_dataset={}
for key in source:
cmumosei_dataset[key]=mmdatasdk.mmdataset(source[key],'cmumosei_%s/'%key)
return cmumosei_dataset
def process_data(folders=["cmumosei_highlevel","cmumosei_labels"]):
log.status("You can also download all the outputs of this code from here: http://immortal.multicomp.cs.cmu.edu/ACL20Challenge/")
cmumosei_dataset={}
for folder in folders:
cmumosei_dataset[folder.split("_")[1]]=mmdatasdk.mmdataset(folder)
#performs word alignment. Labels are not part of the word alignment process.
cmumosei_dataset["highlevel"].align("glove_vectors")
#replacing missing modality information for words - some words may experience failed COVAREP, etc.
cmumosei_dataset["highlevel"].impute('glove_vectors')
#this writes the word aligned computational sequences to the disk
deploy(cmumosei_dataset["highlevel"],"word_aligned_highlevel")
#if you want to load the word aligned from the disk, comment out the lines for align and impute, and uncomment the line below.
#cmumosei_dataset["highlevel"]=mmdatasdk.mmdataset("word_aligned_highlevel")
#now aligning to the labels - first adding labels to the dataset
cmumosei_dataset["highlevel"].computational_sequences["All Labels"]=cmumosei_dataset["labels"]["All Labels"]
#the actual alignment without collapse function this time
cmumosei_dataset["highlevel"].align("All Labels")
#removing sentences which have missing modality information
cmumosei_dataset["highlevel"].hard_unify()
#writing the final aligned to disk
deploy(cmumosei_dataset["highlevel"],"final_aligned")
#reading from the disk - if the above process is done.
#cmumosei_dataset["highlevel"]=mmdatasdk.mmdataset("final_aligned")
#getting the final tensors for machine learning - pass the folds to this function to get data based on tr,va,te folds.
tensors=cmumosei_dataset["highlevel"].get_tensors(seq_len=50,non_sequences=["All Labels"],direction=False,folds=[mmdatasdk.cmu_mosei.standard_folds.standard_train_fold,mmdatasdk.cmu_mosei.standard_folds.standard_valid_fold,mmdatasdk.cmu_mosei.standard_folds.standard_test_fold])
fold_names=["train","valid","test"]
for i in range(3):
#output the shape of the tensors
for csd in list(cmumosei_dataset["highlevel"].keys()):
print ("Shape of the %s computational sequence for %s fold is %s"%(csd,fold_names[i],tensors[i][csd].shape))
if __name__=="__main__":
print ("You only need to download the data once!")
cmumosei_dataset=download_data()
process_data()
log.success("Dataset processed")
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/examples/mmdatasdk_examples/full_examples/process_mosei.py |
#word_level_align.py
#first aligns a dataset to the words vectors and collapses other modalities (by taking average of them for the duration of the word). After this operation every modality will have the same frequency (same as word vectors). Then the code aligns based on opinion labels (note that collapse does not happen for this step.
import mmsdk
from mmsdk import mmdatasdk
import numpy
#uncomment all the ==> lines together
#A simple averaging technique. More advanced methods can be built based on intervals.
def myavg(intervals,features):
return numpy.average(features,axis=0)
#Downloading the dataset
cmumosi_highlevel=mmdatasdk.mmdataset(mmdatasdk.cmu_mosi.highlevel,'cmumosi/')
#cmumosi_highlevel=mmdatasdk.mmdataset('cmumosi/')
#some random video from cmumosi_highlevel
#==>some_video=list(cmumosi_highlevel["glove_vectors"].data.keys())[0]
#The next line is not needed for standard datasets as they are all sorted based on intervals in computational sequence entries
#cmumosi_highlevel.sort()
#Aligning to the words to get word-level alignments
cmumosi_highlevel.align('glove_vectors',collapse_functions=[myavg])
cmumosi_highlevel.impute('glove_vectors')
#get the intervals and features accompanying the 100th word in the some_video
#==>some_video_100th_word=some_video+'[100]'
#==>for compseq_name in list(cmumosi_highlevel.computational_sequences.keys()):
#==> compseq=cmumosi_highlevel[compseq_name]
#==> print (compseq_name)
#==> print (numpy.array(compseq.data[some_video_100th_word]["intervals"]).shape,numpy.array(compseq.data[some_video_100th_word]["features"]).shape)
#==> print ("-------")
#Aligning to the computational labels, thus removing the unsupervised components of CMU-MOSI
cmumosi_highlevel.add_computational_sequences(mmdatasdk.cmu_mosi.labels,'cmumosi/')
cmumosi_highlevel.align('Opinion Segment Labels')
cmumosi_highlevel.hard_unify()
#get the intervals and features accompanying the 2nd in some_video
#==>some_video_2nd_segment=some_video+'[2]'
#==>for compseq_name in list(cmumosi_highlevel.computational_sequences.keys()):
#==> compseq=cmumosi_highlevel[compseq_name]
#==> print (compseq_name)
#==> print (numpy.array(compseq.data[some_video_2nd_segment]["intervals"]).shape,numpy.array(compseq.data[some_video_2nd_segment]["features"]).shape)
#==> print ("-------")
#Deploying the files to the disk and reading them again - Building machine learning models start right after this. No need to do alignment multiple times since aligned files can be deployed and used again.
deploy_files={x:x for x in cmumosi_highlevel.computational_sequences.keys()}
cmumosi_highlevel.deploy("./deployed",deploy_files)
#Reading the dumped file can be as easy as just calling the mmdataset on the deployed folder
aligned_cmumosi_highlevel=mmdatasdk.mmdataset('./deployed')
#Now let's get the tensor ready for ML - right here we just get everything into ML ready tensors. But you should split the aligned_cmumosi_highlevel based on the standard CMU MOSI folds
#get the standard folds using mmsdk.mmdatasdk.cmu_mosi.standard_folds.standard_x_fold for x={train,test,valid}
tensors=cmumosi_highlevel.get_tensors(seq_len=25,non_sequences=["Opinion Segment Labels"],direction=False,folds=[mmdatasdk.cmu_mosi.standard_folds.standard_train_fold,mmdatasdk.cmu_mosi.standard_folds.standard_valid_fold,mmdatasdk.cmu_mosi.standard_folds.standard_test_fold])
fold_names=["train","valid","test"]
for i in range(3):
for csd in list(cmumosi_highlevel.keys()):
print ("Shape of the %s computational sequence for %s fold is %s"%(csd,fold_names[i],tensors[i][csd].shape))
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/examples/mmdatasdk_examples/full_examples/process_mosi.py |
#scenario1.py
#performs imputations and unifies to make sure they remain functional after changes.
import mmsdk
from mmsdk import mmdatasdk
import numpy
import sys
#uncomment all the ==> lines together
#A simple averaging technique. More advanced methods can be built based on intervals.
def myavg(intervals,features):
return numpy.average(features,axis=0)
def impute_and_unify_diagnostics():
cmumosi_highlevel=mmdatasdk.mmdataset(mmdatasdk.cmu_mosi.highlevel,'cmumosi/')
#removing one video to check the unify()
some_video=list(cmumosi_highlevel["glove_vectors"].data.keys())[0]
cmumosi_highlevel["glove_vectors"]._remove_id(some_video)
cmumosi_highlevel.unify()
#Aligning to the words to get word-level alignments
cmumosi_highlevel.align('glove_vectors',collapse_functions=[myavg])
#removing one segment to check the unify()
some_word=list(cmumosi_highlevel["glove_vectors"].data.keys())[0]
some_word_video=some_word.split("[")[0]
cmumosi_highlevel["glove_vectors"]._remove_id(some_word)
cmumosi_highlevel.impute('glove_vectors')
#removing an entire video using purge to check unify
cmumosi_highlevel["glove_vectors"]._remove_id(some_word_video,purge=True)
cmumosi_highlevel.revert()
return True
if __name__=='__main__':
impute_and_unify_diagnostics()
print ("Test finished with python version %s"%str(sys.version_info))
| EXA-1-master | exa/libraries/CMU-MultimodalSDK-master/examples/sdk_diagnostics/scenario1.py |
from setuptools import setup, find_packages
setup(
name='latent-diffusion',
version='0.0.1',
description='',
packages=find_packages(),
install_requires=[
'torch',
'numpy',
'tqdm',
],
) | EXA-1-master | exa/libraries/latent-diffusion/setup.py |
from torchvision.datasets.utils import download_url
from ldm.util import instantiate_from_config
import torch
import os
# todo ?
from google.colab import files
from IPython.display import Image as ipyimg
import ipywidgets as widgets
from PIL import Image
from numpy import asarray
from einops import rearrange, repeat
import torch, torchvision
from ldm.models.diffusion.ddim import DDIMSampler
from ldm.util import ismap
import time
from omegaconf import OmegaConf
def download_models(mode):
if mode == "superresolution":
# this is the small bsr light model
url_conf = 'https://heibox.uni-heidelberg.de/f/31a76b13ea27482981b4/?dl=1'
url_ckpt = 'https://heibox.uni-heidelberg.de/f/578df07c8fc04ffbadf3/?dl=1'
path_conf = 'logs/diffusion/superresolution_bsr/configs/project.yaml'
path_ckpt = 'logs/diffusion/superresolution_bsr/checkpoints/last.ckpt'
download_url(url_conf, path_conf)
download_url(url_ckpt, path_ckpt)
path_conf = path_conf + '/?dl=1' # fix it
path_ckpt = path_ckpt + '/?dl=1' # fix it
return path_conf, path_ckpt
else:
raise NotImplementedError
def load_model_from_config(config, ckpt):
print(f"Loading model from {ckpt}")
pl_sd = torch.load(ckpt, map_location="cpu")
global_step = pl_sd["global_step"]
sd = pl_sd["state_dict"]
model = instantiate_from_config(config.model)
m, u = model.load_state_dict(sd, strict=False)
model.cuda()
model.eval()
return {"model": model}, global_step
def get_model(mode):
path_conf, path_ckpt = download_models(mode)
config = OmegaConf.load(path_conf)
model, step = load_model_from_config(config, path_ckpt)
return model
def get_custom_cond(mode):
dest = "data/example_conditioning"
if mode == "superresolution":
uploaded_img = files.upload()
filename = next(iter(uploaded_img))
name, filetype = filename.split(".") # todo assumes just one dot in name !
os.rename(f"{filename}", f"{dest}/{mode}/custom_{name}.{filetype}")
elif mode == "text_conditional":
w = widgets.Text(value='A cake with cream!', disabled=True)
display(w)
with open(f"{dest}/{mode}/custom_{w.value[:20]}.txt", 'w') as f:
f.write(w.value)
elif mode == "class_conditional":
w = widgets.IntSlider(min=0, max=1000)
display(w)
with open(f"{dest}/{mode}/custom.txt", 'w') as f:
f.write(w.value)
else:
raise NotImplementedError(f"cond not implemented for mode{mode}")
def get_cond_options(mode):
path = "data/example_conditioning"
path = os.path.join(path, mode)
onlyfiles = [f for f in sorted(os.listdir(path))]
return path, onlyfiles
def select_cond_path(mode):
path = "data/example_conditioning" # todo
path = os.path.join(path, mode)
onlyfiles = [f for f in sorted(os.listdir(path))]
selected = widgets.RadioButtons(
options=onlyfiles,
description='Select conditioning:',
disabled=False
)
display(selected)
selected_path = os.path.join(path, selected.value)
return selected_path
def get_cond(mode, selected_path):
example = dict()
if mode == "superresolution":
up_f = 4
visualize_cond_img(selected_path)
c = Image.open(selected_path)
c = torch.unsqueeze(torchvision.transforms.ToTensor()(c), 0)
c_up = torchvision.transforms.functional.resize(c, size=[up_f * c.shape[2], up_f * c.shape[3]], antialias=True)
c_up = rearrange(c_up, '1 c h w -> 1 h w c')
c = rearrange(c, '1 c h w -> 1 h w c')
c = 2. * c - 1.
c = c.to(torch.device("cuda"))
example["LR_image"] = c
example["image"] = c_up
return example
def visualize_cond_img(path):
display(ipyimg(filename=path))
def run(model, selected_path, task, custom_steps, resize_enabled=False, classifier_ckpt=None, global_step=None):
example = get_cond(task, selected_path)
save_intermediate_vid = False
n_runs = 1
masked = False
guider = None
ckwargs = None
mode = 'ddim'
ddim_use_x0_pred = False
temperature = 1.
eta = 1.
make_progrow = True
custom_shape = None
height, width = example["image"].shape[1:3]
split_input = height >= 128 and width >= 128
if split_input:
ks = 128
stride = 64
vqf = 4 #
model.split_input_params = {"ks": (ks, ks), "stride": (stride, stride),
"vqf": vqf,
"patch_distributed_vq": True,
"tie_braker": False,
"clip_max_weight": 0.5,
"clip_min_weight": 0.01,
"clip_max_tie_weight": 0.5,
"clip_min_tie_weight": 0.01}
else:
if hasattr(model, "split_input_params"):
delattr(model, "split_input_params")
invert_mask = False
x_T = None
for n in range(n_runs):
if custom_shape is not None:
x_T = torch.randn(1, custom_shape[1], custom_shape[2], custom_shape[3]).to(model.device)
x_T = repeat(x_T, '1 c h w -> b c h w', b=custom_shape[0])
logs = make_convolutional_sample(example, model,
mode=mode, custom_steps=custom_steps,
eta=eta, swap_mode=False , masked=masked,
invert_mask=invert_mask, quantize_x0=False,
custom_schedule=None, decode_interval=10,
resize_enabled=resize_enabled, custom_shape=custom_shape,
temperature=temperature, noise_dropout=0.,
corrector=guider, corrector_kwargs=ckwargs, x_T=x_T, save_intermediate_vid=save_intermediate_vid,
make_progrow=make_progrow,ddim_use_x0_pred=ddim_use_x0_pred
)
return logs
@torch.no_grad()
def convsample_ddim(model, cond, steps, shape, eta=1.0, callback=None, normals_sequence=None,
mask=None, x0=None, quantize_x0=False, img_callback=None,
temperature=1., noise_dropout=0., score_corrector=None,
corrector_kwargs=None, x_T=None, log_every_t=None
):
ddim = DDIMSampler(model)
bs = shape[0] # dont know where this comes from but wayne
shape = shape[1:] # cut batch dim
print(f"Sampling with eta = {eta}; steps: {steps}")
samples, intermediates = ddim.sample(steps, batch_size=bs, shape=shape, conditioning=cond, callback=callback,
normals_sequence=normals_sequence, quantize_x0=quantize_x0, eta=eta,
mask=mask, x0=x0, temperature=temperature, verbose=False,
score_corrector=score_corrector,
corrector_kwargs=corrector_kwargs, x_T=x_T)
return samples, intermediates
@torch.no_grad()
def make_convolutional_sample(batch, model, mode="vanilla", custom_steps=None, eta=1.0, swap_mode=False, masked=False,
invert_mask=True, quantize_x0=False, custom_schedule=None, decode_interval=1000,
resize_enabled=False, custom_shape=None, temperature=1., noise_dropout=0., corrector=None,
corrector_kwargs=None, x_T=None, save_intermediate_vid=False, make_progrow=True,ddim_use_x0_pred=False):
log = dict()
z, c, x, xrec, xc = model.get_input(batch, model.first_stage_key,
return_first_stage_outputs=True,
force_c_encode=not (hasattr(model, 'split_input_params')
and model.cond_stage_key == 'coordinates_bbox'),
return_original_cond=True)
log_every_t = 1 if save_intermediate_vid else None
if custom_shape is not None:
z = torch.randn(custom_shape)
print(f"Generating {custom_shape[0]} samples of shape {custom_shape[1:]}")
z0 = None
log["input"] = x
log["reconstruction"] = xrec
if ismap(xc):
log["original_conditioning"] = model.to_rgb(xc)
if hasattr(model, 'cond_stage_key'):
log[model.cond_stage_key] = model.to_rgb(xc)
else:
log["original_conditioning"] = xc if xc is not None else torch.zeros_like(x)
if model.cond_stage_model:
log[model.cond_stage_key] = xc if xc is not None else torch.zeros_like(x)
if model.cond_stage_key =='class_label':
log[model.cond_stage_key] = xc[model.cond_stage_key]
with model.ema_scope("Plotting"):
t0 = time.time()
img_cb = None
sample, intermediates = convsample_ddim(model, c, steps=custom_steps, shape=z.shape,
eta=eta,
quantize_x0=quantize_x0, img_callback=img_cb, mask=None, x0=z0,
temperature=temperature, noise_dropout=noise_dropout,
score_corrector=corrector, corrector_kwargs=corrector_kwargs,
x_T=x_T, log_every_t=log_every_t)
t1 = time.time()
if ddim_use_x0_pred:
sample = intermediates['pred_x0'][-1]
x_sample = model.decode_first_stage(sample)
try:
x_sample_noquant = model.decode_first_stage(sample, force_not_quantize=True)
log["sample_noquant"] = x_sample_noquant
log["sample_diff"] = torch.abs(x_sample_noquant - x_sample)
except:
pass
log["sample"] = x_sample
log["time"] = t1 - t0
return log | EXA-1-master | exa/libraries/latent-diffusion/notebook_helpers.py |
import argparse, os, sys, datetime, glob, importlib, csv
import numpy as np
import time
import torch
import torchvision
import pytorch_lightning as pl
from packaging import version
from omegaconf import OmegaConf
from torch.utils.data import random_split, DataLoader, Dataset, Subset
from functools import partial
from PIL import Image
from pytorch_lightning import seed_everything
from pytorch_lightning.trainer import Trainer
from pytorch_lightning.callbacks import ModelCheckpoint, Callback, LearningRateMonitor
from pytorch_lightning.utilities.distributed import rank_zero_only
from pytorch_lightning.utilities import rank_zero_info
from ldm.data.base import Txt2ImgIterableBaseDataset
from ldm.util import instantiate_from_config
def get_parser(**parser_kwargs):
def str2bool(v):
if isinstance(v, bool):
return v
if v.lower() in ("yes", "true", "t", "y", "1"):
return True
elif v.lower() in ("no", "false", "f", "n", "0"):
return False
else:
raise argparse.ArgumentTypeError("Boolean value expected.")
parser = argparse.ArgumentParser(**parser_kwargs)
parser.add_argument(
"-n",
"--name",
type=str,
const=True,
default="",
nargs="?",
help="postfix for logdir",
)
parser.add_argument(
"-r",
"--resume",
type=str,
const=True,
default="",
nargs="?",
help="resume from logdir or checkpoint in logdir",
)
parser.add_argument(
"-b",
"--base",
nargs="*",
metavar="base_config.yaml",
help="paths to base configs. Loaded from left-to-right. "
"Parameters can be overwritten or added with command-line options of the form `--key value`.",
default=list(),
)
parser.add_argument(
"-t",
"--train",
type=str2bool,
const=True,
default=False,
nargs="?",
help="train",
)
parser.add_argument(
"--no-test",
type=str2bool,
const=True,
default=False,
nargs="?",
help="disable test",
)
parser.add_argument(
"-p",
"--project",
help="name of new or path to existing project"
)
parser.add_argument(
"-d",
"--debug",
type=str2bool,
nargs="?",
const=True,
default=False,
help="enable post-mortem debugging",
)
parser.add_argument(
"-s",
"--seed",
type=int,
default=23,
help="seed for seed_everything",
)
parser.add_argument(
"-f",
"--postfix",
type=str,
default="",
help="post-postfix for default name",
)
parser.add_argument(
"-l",
"--logdir",
type=str,
default="logs",
help="directory for logging dat shit",
)
parser.add_argument(
"--scale_lr",
type=str2bool,
nargs="?",
const=True,
default=True,
help="scale base-lr by ngpu * batch_size * n_accumulate",
)
return parser
def nondefault_trainer_args(opt):
parser = argparse.ArgumentParser()
parser = Trainer.add_argparse_args(parser)
args = parser.parse_args([])
return sorted(k for k in vars(args) if getattr(opt, k) != getattr(args, k))
class WrappedDataset(Dataset):
"""Wraps an arbitrary object with __len__ and __getitem__ into a pytorch dataset"""
def __init__(self, dataset):
self.data = dataset
def __len__(self):
return len(self.data)
def __getitem__(self, idx):
return self.data[idx]
def worker_init_fn(_):
worker_info = torch.utils.data.get_worker_info()
dataset = worker_info.dataset
worker_id = worker_info.id
if isinstance(dataset, Txt2ImgIterableBaseDataset):
split_size = dataset.num_records // worker_info.num_workers
# reset num_records to the true number to retain reliable length information
dataset.sample_ids = dataset.valid_ids[worker_id * split_size:(worker_id + 1) * split_size]
current_id = np.random.choice(len(np.random.get_state()[1]), 1)
return np.random.seed(np.random.get_state()[1][current_id] + worker_id)
else:
return np.random.seed(np.random.get_state()[1][0] + worker_id)
class DataModuleFromConfig(pl.LightningDataModule):
def __init__(self, batch_size, train=None, validation=None, test=None, predict=None,
wrap=False, num_workers=None, shuffle_test_loader=False, use_worker_init_fn=False,
shuffle_val_dataloader=False):
super().__init__()
self.batch_size = batch_size
self.dataset_configs = dict()
self.num_workers = num_workers if num_workers is not None else batch_size * 2
self.use_worker_init_fn = use_worker_init_fn
if train is not None:
self.dataset_configs["train"] = train
self.train_dataloader = self._train_dataloader
if validation is not None:
self.dataset_configs["validation"] = validation
self.val_dataloader = partial(self._val_dataloader, shuffle=shuffle_val_dataloader)
if test is not None:
self.dataset_configs["test"] = test
self.test_dataloader = partial(self._test_dataloader, shuffle=shuffle_test_loader)
if predict is not None:
self.dataset_configs["predict"] = predict
self.predict_dataloader = self._predict_dataloader
self.wrap = wrap
def prepare_data(self):
for data_cfg in self.dataset_configs.values():
instantiate_from_config(data_cfg)
def setup(self, stage=None):
self.datasets = dict(
(k, instantiate_from_config(self.dataset_configs[k]))
for k in self.dataset_configs)
if self.wrap:
for k in self.datasets:
self.datasets[k] = WrappedDataset(self.datasets[k])
def _train_dataloader(self):
is_iterable_dataset = isinstance(self.datasets['train'], Txt2ImgIterableBaseDataset)
if is_iterable_dataset or self.use_worker_init_fn:
init_fn = worker_init_fn
else:
init_fn = None
return DataLoader(self.datasets["train"], batch_size=self.batch_size,
num_workers=self.num_workers, shuffle=False if is_iterable_dataset else True,
worker_init_fn=init_fn)
def _val_dataloader(self, shuffle=False):
if isinstance(self.datasets['validation'], Txt2ImgIterableBaseDataset) or self.use_worker_init_fn:
init_fn = worker_init_fn
else:
init_fn = None
return DataLoader(self.datasets["validation"],
batch_size=self.batch_size,
num_workers=self.num_workers,
worker_init_fn=init_fn,
shuffle=shuffle)
def _test_dataloader(self, shuffle=False):
is_iterable_dataset = isinstance(self.datasets['train'], Txt2ImgIterableBaseDataset)
if is_iterable_dataset or self.use_worker_init_fn:
init_fn = worker_init_fn
else:
init_fn = None
# do not shuffle dataloader for iterable dataset
shuffle = shuffle and (not is_iterable_dataset)
return DataLoader(self.datasets["test"], batch_size=self.batch_size,
num_workers=self.num_workers, worker_init_fn=init_fn, shuffle=shuffle)
def _predict_dataloader(self, shuffle=False):
if isinstance(self.datasets['predict'], Txt2ImgIterableBaseDataset) or self.use_worker_init_fn:
init_fn = worker_init_fn
else:
init_fn = None
return DataLoader(self.datasets["predict"], batch_size=self.batch_size,
num_workers=self.num_workers, worker_init_fn=init_fn)
class SetupCallback(Callback):
def __init__(self, resume, now, logdir, ckptdir, cfgdir, config, lightning_config):
super().__init__()
self.resume = resume
self.now = now
self.logdir = logdir
self.ckptdir = ckptdir
self.cfgdir = cfgdir
self.config = config
self.lightning_config = lightning_config
def on_keyboard_interrupt(self, trainer, pl_module):
if trainer.global_rank == 0:
print("Summoning checkpoint.")
ckpt_path = os.path.join(self.ckptdir, "last.ckpt")
trainer.save_checkpoint(ckpt_path)
def on_pretrain_routine_start(self, trainer, pl_module):
if trainer.global_rank == 0:
# Create logdirs and save configs
os.makedirs(self.logdir, exist_ok=True)
os.makedirs(self.ckptdir, exist_ok=True)
os.makedirs(self.cfgdir, exist_ok=True)
if "callbacks" in self.lightning_config:
if 'metrics_over_trainsteps_checkpoint' in self.lightning_config['callbacks']:
os.makedirs(os.path.join(self.ckptdir, 'trainstep_checkpoints'), exist_ok=True)
print("Project config")
print(OmegaConf.to_yaml(self.config))
OmegaConf.save(self.config,
os.path.join(self.cfgdir, "{}-project.yaml".format(self.now)))
print("Lightning config")
print(OmegaConf.to_yaml(self.lightning_config))
OmegaConf.save(OmegaConf.create({"lightning": self.lightning_config}),
os.path.join(self.cfgdir, "{}-lightning.yaml".format(self.now)))
else:
# ModelCheckpoint callback created log directory --- remove it
if not self.resume and os.path.exists(self.logdir):
dst, name = os.path.split(self.logdir)
dst = os.path.join(dst, "child_runs", name)
os.makedirs(os.path.split(dst)[0], exist_ok=True)
try:
os.rename(self.logdir, dst)
except FileNotFoundError:
pass
class ImageLogger(Callback):
def __init__(self, batch_frequency, max_images, clamp=True, increase_log_steps=True,
rescale=True, disabled=False, log_on_batch_idx=False, log_first_step=False,
log_images_kwargs=None):
super().__init__()
self.rescale = rescale
self.batch_freq = batch_frequency
self.max_images = max_images
self.logger_log_images = {
pl.loggers.TestTubeLogger: self._testtube,
}
self.log_steps = [2 ** n for n in range(int(np.log2(self.batch_freq)) + 1)]
if not increase_log_steps:
self.log_steps = [self.batch_freq]
self.clamp = clamp
self.disabled = disabled
self.log_on_batch_idx = log_on_batch_idx
self.log_images_kwargs = log_images_kwargs if log_images_kwargs else {}
self.log_first_step = log_first_step
@rank_zero_only
def _testtube(self, pl_module, images, batch_idx, split):
for k in images:
grid = torchvision.utils.make_grid(images[k])
grid = (grid + 1.0) / 2.0 # -1,1 -> 0,1; c,h,w
tag = f"{split}/{k}"
pl_module.logger.experiment.add_image(
tag, grid,
global_step=pl_module.global_step)
@rank_zero_only
def log_local(self, save_dir, split, images,
global_step, current_epoch, batch_idx):
root = os.path.join(save_dir, "images", split)
for k in images:
grid = torchvision.utils.make_grid(images[k], nrow=4)
if self.rescale:
grid = (grid + 1.0) / 2.0 # -1,1 -> 0,1; c,h,w
grid = grid.transpose(0, 1).transpose(1, 2).squeeze(-1)
grid = grid.numpy()
grid = (grid * 255).astype(np.uint8)
filename = "{}_gs-{:06}_e-{:06}_b-{:06}.png".format(
k,
global_step,
current_epoch,
batch_idx)
path = os.path.join(root, filename)
os.makedirs(os.path.split(path)[0], exist_ok=True)
Image.fromarray(grid).save(path)
def log_img(self, pl_module, batch, batch_idx, split="train"):
check_idx = batch_idx if self.log_on_batch_idx else pl_module.global_step
if (self.check_frequency(check_idx) and # batch_idx % self.batch_freq == 0
hasattr(pl_module, "log_images") and
callable(pl_module.log_images) and
self.max_images > 0):
logger = type(pl_module.logger)
is_train = pl_module.training
if is_train:
pl_module.eval()
with torch.no_grad():
images = pl_module.log_images(batch, split=split, **self.log_images_kwargs)
for k in images:
N = min(images[k].shape[0], self.max_images)
images[k] = images[k][:N]
if isinstance(images[k], torch.Tensor):
images[k] = images[k].detach().cpu()
if self.clamp:
images[k] = torch.clamp(images[k], -1., 1.)
self.log_local(pl_module.logger.save_dir, split, images,
pl_module.global_step, pl_module.current_epoch, batch_idx)
logger_log_images = self.logger_log_images.get(logger, lambda *args, **kwargs: None)
logger_log_images(pl_module, images, pl_module.global_step, split)
if is_train:
pl_module.train()
def check_frequency(self, check_idx):
if ((check_idx % self.batch_freq) == 0 or (check_idx in self.log_steps)) and (
check_idx > 0 or self.log_first_step):
try:
self.log_steps.pop(0)
except IndexError as e:
print(e)
pass
return True
return False
def on_train_batch_end(self, trainer, pl_module, outputs, batch, batch_idx, dataloader_idx):
if not self.disabled and (pl_module.global_step > 0 or self.log_first_step):
self.log_img(pl_module, batch, batch_idx, split="train")
def on_validation_batch_end(self, trainer, pl_module, outputs, batch, batch_idx, dataloader_idx):
if not self.disabled and pl_module.global_step > 0:
self.log_img(pl_module, batch, batch_idx, split="val")
if hasattr(pl_module, 'calibrate_grad_norm'):
if (pl_module.calibrate_grad_norm and batch_idx % 25 == 0) and batch_idx > 0:
self.log_gradients(trainer, pl_module, batch_idx=batch_idx)
class CUDACallback(Callback):
# see https://github.com/SeanNaren/minGPT/blob/master/mingpt/callback.py
def on_train_epoch_start(self, trainer, pl_module):
# Reset the memory use counter
torch.cuda.reset_peak_memory_stats(trainer.root_gpu)
torch.cuda.synchronize(trainer.root_gpu)
self.start_time = time.time()
def on_train_epoch_end(self, trainer, pl_module, outputs):
torch.cuda.synchronize(trainer.root_gpu)
max_memory = torch.cuda.max_memory_allocated(trainer.root_gpu) / 2 ** 20
epoch_time = time.time() - self.start_time
try:
max_memory = trainer.training_type_plugin.reduce(max_memory)
epoch_time = trainer.training_type_plugin.reduce(epoch_time)
rank_zero_info(f"Average Epoch time: {epoch_time:.2f} seconds")
rank_zero_info(f"Average Peak memory {max_memory:.2f}MiB")
except AttributeError:
pass
if __name__ == "__main__":
# custom parser to specify config files, train, test and debug mode,
# postfix, resume.
# `--key value` arguments are interpreted as arguments to the trainer.
# `nested.key=value` arguments are interpreted as config parameters.
# configs are merged from left-to-right followed by command line parameters.
# model:
# base_learning_rate: float
# target: path to lightning module
# params:
# key: value
# data:
# target: main.DataModuleFromConfig
# params:
# batch_size: int
# wrap: bool
# train:
# target: path to train dataset
# params:
# key: value
# validation:
# target: path to validation dataset
# params:
# key: value
# test:
# target: path to test dataset
# params:
# key: value
# lightning: (optional, has sane defaults and can be specified on cmdline)
# trainer:
# additional arguments to trainer
# logger:
# logger to instantiate
# modelcheckpoint:
# modelcheckpoint to instantiate
# callbacks:
# callback1:
# target: importpath
# params:
# key: value
now = datetime.datetime.now().strftime("%Y-%m-%dT%H-%M-%S")
# add cwd for convenience and to make classes in this file available when
# running as `python main.py`
# (in particular `main.DataModuleFromConfig`)
sys.path.append(os.getcwd())
parser = get_parser()
parser = Trainer.add_argparse_args(parser)
opt, unknown = parser.parse_known_args()
if opt.name and opt.resume:
raise ValueError(
"-n/--name and -r/--resume cannot be specified both."
"If you want to resume training in a new log folder, "
"use -n/--name in combination with --resume_from_checkpoint"
)
if opt.resume:
if not os.path.exists(opt.resume):
raise ValueError("Cannot find {}".format(opt.resume))
if os.path.isfile(opt.resume):
paths = opt.resume.split("/")
# idx = len(paths)-paths[::-1].index("logs")+1
# logdir = "/".join(paths[:idx])
logdir = "/".join(paths[:-2])
ckpt = opt.resume
else:
assert os.path.isdir(opt.resume), opt.resume
logdir = opt.resume.rstrip("/")
ckpt = os.path.join(logdir, "checkpoints", "last.ckpt")
opt.resume_from_checkpoint = ckpt
base_configs = sorted(glob.glob(os.path.join(logdir, "configs/*.yaml")))
opt.base = base_configs + opt.base
_tmp = logdir.split("/")
nowname = _tmp[-1]
else:
if opt.name:
name = "_" + opt.name
elif opt.base:
cfg_fname = os.path.split(opt.base[0])[-1]
cfg_name = os.path.splitext(cfg_fname)[0]
name = "_" + cfg_name
else:
name = ""
nowname = now + name + opt.postfix
logdir = os.path.join(opt.logdir, nowname)
ckptdir = os.path.join(logdir, "checkpoints")
cfgdir = os.path.join(logdir, "configs")
seed_everything(opt.seed)
try:
# init and save configs
configs = [OmegaConf.load(cfg) for cfg in opt.base]
cli = OmegaConf.from_dotlist(unknown)
config = OmegaConf.merge(*configs, cli)
lightning_config = config.pop("lightning", OmegaConf.create())
# merge trainer cli with config
trainer_config = lightning_config.get("trainer", OmegaConf.create())
# default to ddp
trainer_config["accelerator"] = "ddp"
for k in nondefault_trainer_args(opt):
trainer_config[k] = getattr(opt, k)
if not "gpus" in trainer_config:
del trainer_config["accelerator"]
cpu = True
else:
gpuinfo = trainer_config["gpus"]
print(f"Running on GPUs {gpuinfo}")
cpu = False
trainer_opt = argparse.Namespace(**trainer_config)
lightning_config.trainer = trainer_config
# model
model = instantiate_from_config(config.model)
# trainer and callbacks
trainer_kwargs = dict()
# default logger configs
default_logger_cfgs = {
"wandb": {
"target": "pytorch_lightning.loggers.WandbLogger",
"params": {
"name": nowname,
"save_dir": logdir,
"offline": opt.debug,
"id": nowname,
}
},
"testtube": {
"target": "pytorch_lightning.loggers.TestTubeLogger",
"params": {
"name": "testtube",
"save_dir": logdir,
}
},
}
default_logger_cfg = default_logger_cfgs["testtube"]
if "logger" in lightning_config:
logger_cfg = lightning_config.logger
else:
logger_cfg = OmegaConf.create()
logger_cfg = OmegaConf.merge(default_logger_cfg, logger_cfg)
trainer_kwargs["logger"] = instantiate_from_config(logger_cfg)
# modelcheckpoint - use TrainResult/EvalResult(checkpoint_on=metric) to
# specify which metric is used to determine best models
default_modelckpt_cfg = {
"target": "pytorch_lightning.callbacks.ModelCheckpoint",
"params": {
"dirpath": ckptdir,
"filename": "{epoch:06}",
"verbose": True,
"save_last": True,
}
}
if hasattr(model, "monitor"):
print(f"Monitoring {model.monitor} as checkpoint metric.")
default_modelckpt_cfg["params"]["monitor"] = model.monitor
default_modelckpt_cfg["params"]["save_top_k"] = 3
if "modelcheckpoint" in lightning_config:
modelckpt_cfg = lightning_config.modelcheckpoint
else:
modelckpt_cfg = OmegaConf.create()
modelckpt_cfg = OmegaConf.merge(default_modelckpt_cfg, modelckpt_cfg)
print(f"Merged modelckpt-cfg: \n{modelckpt_cfg}")
if version.parse(pl.__version__) < version.parse('1.4.0'):
trainer_kwargs["checkpoint_callback"] = instantiate_from_config(modelckpt_cfg)
# add callback which sets up log directory
default_callbacks_cfg = {
"setup_callback": {
"target": "main.SetupCallback",
"params": {
"resume": opt.resume,
"now": now,
"logdir": logdir,
"ckptdir": ckptdir,
"cfgdir": cfgdir,
"config": config,
"lightning_config": lightning_config,
}
},
"image_logger": {
"target": "main.ImageLogger",
"params": {
"batch_frequency": 750,
"max_images": 4,
"clamp": True
}
},
"learning_rate_logger": {
"target": "main.LearningRateMonitor",
"params": {
"logging_interval": "step",
# "log_momentum": True
}
},
"cuda_callback": {
"target": "main.CUDACallback"
},
}
if version.parse(pl.__version__) >= version.parse('1.4.0'):
default_callbacks_cfg.update({'checkpoint_callback': modelckpt_cfg})
if "callbacks" in lightning_config:
callbacks_cfg = lightning_config.callbacks
else:
callbacks_cfg = OmegaConf.create()
if 'metrics_over_trainsteps_checkpoint' in callbacks_cfg:
print(
'Caution: Saving checkpoints every n train steps without deleting. This might require some free space.')
default_metrics_over_trainsteps_ckpt_dict = {
'metrics_over_trainsteps_checkpoint':
{"target": 'pytorch_lightning.callbacks.ModelCheckpoint',
'params': {
"dirpath": os.path.join(ckptdir, 'trainstep_checkpoints'),
"filename": "{epoch:06}-{step:09}",
"verbose": True,
'save_top_k': -1,
'every_n_train_steps': 10000,
'save_weights_only': True
}
}
}
default_callbacks_cfg.update(default_metrics_over_trainsteps_ckpt_dict)
callbacks_cfg = OmegaConf.merge(default_callbacks_cfg, callbacks_cfg)
if 'ignore_keys_callback' in callbacks_cfg and hasattr(trainer_opt, 'resume_from_checkpoint'):
callbacks_cfg.ignore_keys_callback.params['ckpt_path'] = trainer_opt.resume_from_checkpoint
elif 'ignore_keys_callback' in callbacks_cfg:
del callbacks_cfg['ignore_keys_callback']
trainer_kwargs["callbacks"] = [instantiate_from_config(callbacks_cfg[k]) for k in callbacks_cfg]
trainer = Trainer.from_argparse_args(trainer_opt, **trainer_kwargs)
trainer.logdir = logdir ###
# data
data = instantiate_from_config(config.data)
# NOTE according to https://pytorch-lightning.readthedocs.io/en/latest/datamodules.html
# calling these ourselves should not be necessary but it is.
# lightning still takes care of proper multiprocessing though
data.prepare_data()
data.setup()
print("#### Data #####")
for k in data.datasets:
print(f"{k}, {data.datasets[k].__class__.__name__}, {len(data.datasets[k])}")
# configure learning rate
bs, base_lr = config.data.params.batch_size, config.model.base_learning_rate
if not cpu:
ngpu = len(lightning_config.trainer.gpus.strip(",").split(','))
else:
ngpu = 1
if 'accumulate_grad_batches' in lightning_config.trainer:
accumulate_grad_batches = lightning_config.trainer.accumulate_grad_batches
else:
accumulate_grad_batches = 1
print(f"accumulate_grad_batches = {accumulate_grad_batches}")
lightning_config.trainer.accumulate_grad_batches = accumulate_grad_batches
if opt.scale_lr:
model.learning_rate = accumulate_grad_batches * ngpu * bs * base_lr
print(
"Setting learning rate to {:.2e} = {} (accumulate_grad_batches) * {} (num_gpus) * {} (batchsize) * {:.2e} (base_lr)".format(
model.learning_rate, accumulate_grad_batches, ngpu, bs, base_lr))
else:
model.learning_rate = base_lr
print("++++ NOT USING LR SCALING ++++")
print(f"Setting learning rate to {model.learning_rate:.2e}")
# allow checkpointing via USR1
def melk(*args, **kwargs):
# run all checkpoint hooks
if trainer.global_rank == 0:
print("Summoning checkpoint.")
ckpt_path = os.path.join(ckptdir, "last.ckpt")
trainer.save_checkpoint(ckpt_path)
def divein(*args, **kwargs):
if trainer.global_rank == 0:
import pudb;
pudb.set_trace()
import signal
signal.signal(signal.SIGUSR1, melk)
signal.signal(signal.SIGUSR2, divein)
# run
if opt.train:
try:
trainer.fit(model, data)
except Exception:
melk()
raise
if not opt.no_test and not trainer.interrupted:
trainer.test(model, data)
except Exception:
if opt.debug and trainer.global_rank == 0:
try:
import pudb as debugger
except ImportError:
import pdb as debugger
debugger.post_mortem()
raise
finally:
# move newly created debug project to debug_runs
if opt.debug and not opt.resume and trainer.global_rank == 0:
dst, name = os.path.split(logdir)
dst = os.path.join(dst, "debug_runs", name)
os.makedirs(os.path.split(dst)[0], exist_ok=True)
os.rename(logdir, dst)
if trainer.global_rank == 0:
print(trainer.profiler.summary())
| EXA-1-master | exa/libraries/latent-diffusion/main.py |
import argparse, os, sys, glob
from omegaconf import OmegaConf
from PIL import Image
from tqdm import tqdm
import numpy as np
import torch
from main import instantiate_from_config
from ldm.models.diffusion.ddim import DDIMSampler
def make_batch(image, mask, device):
image = np.array(Image.open(image).convert("RGB"))
image = image.astype(np.float32)/255.0
image = image[None].transpose(0,3,1,2)
image = torch.from_numpy(image)
mask = np.array(Image.open(mask).convert("L"))
mask = mask.astype(np.float32)/255.0
mask = mask[None,None]
mask[mask < 0.5] = 0
mask[mask >= 0.5] = 1
mask = torch.from_numpy(mask)
masked_image = (1-mask)*image
batch = {"image": image, "mask": mask, "masked_image": masked_image}
for k in batch:
batch[k] = batch[k].to(device=device)
batch[k] = batch[k]*2.0-1.0
return batch
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument(
"--indir",
type=str,
nargs="?",
help="dir containing image-mask pairs (`example.png` and `example_mask.png`)",
)
parser.add_argument(
"--outdir",
type=str,
nargs="?",
help="dir to write results to",
)
parser.add_argument(
"--steps",
type=int,
default=50,
help="number of ddim sampling steps",
)
opt = parser.parse_args()
masks = sorted(glob.glob(os.path.join(opt.indir, "*_mask.png")))
images = [x.replace("_mask.png", ".png") for x in masks]
print(f"Found {len(masks)} inputs.")
config = OmegaConf.load("models/ldm/inpainting_big/config.yaml")
model = instantiate_from_config(config.model)
model.load_state_dict(torch.load("models/ldm/inpainting_big/last.ckpt")["state_dict"],
strict=False)
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
model = model.to(device)
sampler = DDIMSampler(model)
os.makedirs(opt.outdir, exist_ok=True)
with torch.no_grad():
with model.ema_scope():
for image, mask in tqdm(zip(images, masks)):
outpath = os.path.join(opt.outdir, os.path.split(image)[1])
batch = make_batch(image, mask, device=device)
# encode masked image and concat downsampled mask
c = model.cond_stage_model.encode(batch["masked_image"])
cc = torch.nn.functional.interpolate(batch["mask"],
size=c.shape[-2:])
c = torch.cat((c, cc), dim=1)
shape = (c.shape[1]-1,)+c.shape[2:]
samples_ddim, _ = sampler.sample(S=opt.steps,
conditioning=c,
batch_size=c.shape[0],
shape=shape,
verbose=False)
x_samples_ddim = model.decode_first_stage(samples_ddim)
image = torch.clamp((batch["image"]+1.0)/2.0,
min=0.0, max=1.0)
mask = torch.clamp((batch["mask"]+1.0)/2.0,
min=0.0, max=1.0)
predicted_image = torch.clamp((x_samples_ddim+1.0)/2.0,
min=0.0, max=1.0)
inpainted = (1-mask)*image+mask*predicted_image
inpainted = inpainted.cpu().numpy().transpose(0,2,3,1)[0]*255
Image.fromarray(inpainted.astype(np.uint8)).save(outpath)
| EXA-1-master | exa/libraries/latent-diffusion/scripts/inpaint.py |
import argparse, os, sys, glob
import torch
import numpy as np
from omegaconf import OmegaConf
from PIL import Image
from tqdm import tqdm, trange
from einops import rearrange
from torchvision.utils import make_grid
from ldm.util import instantiate_from_config
from ldm.models.diffusion.ddim import DDIMSampler
from ldm.models.diffusion.plms import PLMSSampler
def load_model_from_config(config, ckpt, verbose=False):
print(f"Loading model from {ckpt}")
pl_sd = torch.load(ckpt, map_location="cpu")
sd = pl_sd["state_dict"]
model = instantiate_from_config(config.model)
m, u = model.load_state_dict(sd, strict=False)
if len(m) > 0 and verbose:
print("missing keys:")
print(m)
if len(u) > 0 and verbose:
print("unexpected keys:")
print(u)
model.cuda()
model.eval()
return model
if __name__ == "__main__":
parser = argparse.ArgumentParser()
parser.add_argument(
"--prompt",
type=str,
nargs="?",
default="a painting of a virus monster playing guitar",
help="the prompt to render"
)
parser.add_argument(
"--outdir",
type=str,
nargs="?",
help="dir to write results to",
default="outputs/txt2img-samples"
)
parser.add_argument(
"--ddim_steps",
type=int,
default=200,
help="number of ddim sampling steps",
)
parser.add_argument(
"--plms",
action='store_true',
help="use plms sampling",
)
parser.add_argument(
"--ddim_eta",
type=float,
default=0.0,
help="ddim eta (eta=0.0 corresponds to deterministic sampling",
)
parser.add_argument(
"--n_iter",
type=int,
default=1,
help="sample this often",
)
parser.add_argument(
"--H",
type=int,
default=256,
help="image height, in pixel space",
)
parser.add_argument(
"--W",
type=int,
default=256,
help="image width, in pixel space",
)
parser.add_argument(
"--n_samples",
type=int,
default=4,
help="how many samples to produce for the given prompt",
)
parser.add_argument(
"--scale",
type=float,
default=5.0,
help="unconditional guidance scale: eps = eps(x, empty) + scale * (eps(x, cond) - eps(x, empty))",
)
opt = parser.parse_args()
config = OmegaConf.load("configs/latent-diffusion/txt2img-1p4B-eval.yaml") # TODO: Optionally download from same location as ckpt and chnage this logic
model = load_model_from_config(config, "models/ldm/text2img-large/model.ckpt") # TODO: check path
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
model = model.to(device)
if opt.plms:
sampler = PLMSSampler(model)
else:
sampler = DDIMSampler(model)
os.makedirs(opt.outdir, exist_ok=True)
outpath = opt.outdir
prompt = opt.prompt
sample_path = os.path.join(outpath, "samples")
os.makedirs(sample_path, exist_ok=True)
base_count = len(os.listdir(sample_path))
all_samples=list()
with torch.no_grad():
with model.ema_scope():
uc = None
if opt.scale != 1.0:
uc = model.get_learned_conditioning(opt.n_samples * [""])
for n in trange(opt.n_iter, desc="Sampling"):
c = model.get_learned_conditioning(opt.n_samples * [prompt])
shape = [4, opt.H//8, opt.W//8]
samples_ddim, _ = sampler.sample(S=opt.ddim_steps,
conditioning=c,
batch_size=opt.n_samples,
shape=shape,
verbose=False,
unconditional_guidance_scale=opt.scale,
unconditional_conditioning=uc,
eta=opt.ddim_eta)
x_samples_ddim = model.decode_first_stage(samples_ddim)
x_samples_ddim = torch.clamp((x_samples_ddim+1.0)/2.0, min=0.0, max=1.0)
for x_sample in x_samples_ddim:
x_sample = 255. * rearrange(x_sample.cpu().numpy(), 'c h w -> h w c')
Image.fromarray(x_sample.astype(np.uint8)).save(os.path.join(sample_path, f"{base_count:04}.png"))
base_count += 1
all_samples.append(x_samples_ddim)
# additionally, save as grid
grid = torch.stack(all_samples, 0)
grid = rearrange(grid, 'n b c h w -> (n b) c h w')
grid = make_grid(grid, nrow=opt.n_samples)
# to image
grid = 255. * rearrange(grid, 'c h w -> h w c').cpu().numpy()
Image.fromarray(grid.astype(np.uint8)).save(os.path.join(outpath, f'{prompt.replace(" ", "-")}.png'))
print(f"Your samples are ready and waiting four you here: \n{outpath} \nEnjoy.")
| EXA-1-master | exa/libraries/latent-diffusion/scripts/txt2img.py |
import argparse, os, sys, glob
import clip
import torch
import torch.nn as nn
import numpy as np
from omegaconf import OmegaConf
from PIL import Image
from tqdm import tqdm, trange
from itertools import islice
from einops import rearrange, repeat
from torchvision.utils import make_grid
import scann
import time
from multiprocessing import cpu_count
from ldm.util import instantiate_from_config, parallel_data_prefetch
from ldm.models.diffusion.ddim import DDIMSampler
from ldm.models.diffusion.plms import PLMSSampler
from ldm.modules.encoders.modules import FrozenClipImageEmbedder, FrozenCLIPTextEmbedder
DATABASES = [
"openimages",
"artbench-art_nouveau",
"artbench-baroque",
"artbench-expressionism",
"artbench-impressionism",
"artbench-post_impressionism",
"artbench-realism",
"artbench-romanticism",
"artbench-renaissance",
"artbench-surrealism",
"artbench-ukiyo_e",
]
def chunk(it, size):
it = iter(it)
return iter(lambda: tuple(islice(it, size)), ())
def load_model_from_config(config, ckpt, verbose=False):
print(f"Loading model from {ckpt}")
pl_sd = torch.load(ckpt, map_location="cpu")
if "global_step" in pl_sd:
print(f"Global Step: {pl_sd['global_step']}")
sd = pl_sd["state_dict"]
model = instantiate_from_config(config.model)
m, u = model.load_state_dict(sd, strict=False)
if len(m) > 0 and verbose:
print("missing keys:")
print(m)
if len(u) > 0 and verbose:
print("unexpected keys:")
print(u)
model.cuda()
model.eval()
return model
class Searcher(object):
def __init__(self, database, retriever_version='ViT-L/14'):
assert database in DATABASES
# self.database = self.load_database(database)
self.database_name = database
self.searcher_savedir = f'data/rdm/searchers/{self.database_name}'
self.database_path = f'data/rdm/retrieval_databases/{self.database_name}'
self.retriever = self.load_retriever(version=retriever_version)
self.database = {'embedding': [],
'img_id': [],
'patch_coords': []}
self.load_database()
self.load_searcher()
def train_searcher(self, k,
metric='dot_product',
searcher_savedir=None):
print('Start training searcher')
searcher = scann.scann_ops_pybind.builder(self.database['embedding'] /
np.linalg.norm(self.database['embedding'], axis=1)[:, np.newaxis],
k, metric)
self.searcher = searcher.score_brute_force().build()
print('Finish training searcher')
if searcher_savedir is not None:
print(f'Save trained searcher under "{searcher_savedir}"')
os.makedirs(searcher_savedir, exist_ok=True)
self.searcher.serialize(searcher_savedir)
def load_single_file(self, saved_embeddings):
compressed = np.load(saved_embeddings)
self.database = {key: compressed[key] for key in compressed.files}
print('Finished loading of clip embeddings.')
def load_multi_files(self, data_archive):
out_data = {key: [] for key in self.database}
for d in tqdm(data_archive, desc=f'Loading datapool from {len(data_archive)} individual files.'):
for key in d.files:
out_data[key].append(d[key])
return out_data
def load_database(self):
print(f'Load saved patch embedding from "{self.database_path}"')
file_content = glob.glob(os.path.join(self.database_path, '*.npz'))
if len(file_content) == 1:
self.load_single_file(file_content[0])
elif len(file_content) > 1:
data = [np.load(f) for f in file_content]
prefetched_data = parallel_data_prefetch(self.load_multi_files, data,
n_proc=min(len(data), cpu_count()), target_data_type='dict')
self.database = {key: np.concatenate([od[key] for od in prefetched_data], axis=1)[0] for key in
self.database}
else:
raise ValueError(f'No npz-files in specified path "{self.database_path}" is this directory existing?')
print(f'Finished loading of retrieval database of length {self.database["embedding"].shape[0]}.')
def load_retriever(self, version='ViT-L/14', ):
model = FrozenClipImageEmbedder(model=version)
if torch.cuda.is_available():
model.cuda()
model.eval()
return model
def load_searcher(self):
print(f'load searcher for database {self.database_name} from {self.searcher_savedir}')
self.searcher = scann.scann_ops_pybind.load_searcher(self.searcher_savedir)
print('Finished loading searcher.')
def search(self, x, k):
if self.searcher is None and self.database['embedding'].shape[0] < 2e4:
self.train_searcher(k) # quickly fit searcher on the fly for small databases
assert self.searcher is not None, 'Cannot search with uninitialized searcher'
if isinstance(x, torch.Tensor):
x = x.detach().cpu().numpy()
if len(x.shape) == 3:
x = x[:, 0]
query_embeddings = x / np.linalg.norm(x, axis=1)[:, np.newaxis]
start = time.time()
nns, distances = self.searcher.search_batched(query_embeddings, final_num_neighbors=k)
end = time.time()
out_embeddings = self.database['embedding'][nns]
out_img_ids = self.database['img_id'][nns]
out_pc = self.database['patch_coords'][nns]
out = {'nn_embeddings': out_embeddings / np.linalg.norm(out_embeddings, axis=-1)[..., np.newaxis],
'img_ids': out_img_ids,
'patch_coords': out_pc,
'queries': x,
'exec_time': end - start,
'nns': nns,
'q_embeddings': query_embeddings}
return out
def __call__(self, x, n):
return self.search(x, n)
if __name__ == "__main__":
parser = argparse.ArgumentParser()
# TODO: add n_neighbors and modes (text-only, text-image-retrieval, image-image retrieval etc)
# TODO: add 'image variation' mode when knn=0 but a single image is given instead of a text prompt?
parser.add_argument(
"--prompt",
type=str,
nargs="?",
default="a painting of a virus monster playing guitar",
help="the prompt to render"
)
parser.add_argument(
"--outdir",
type=str,
nargs="?",
help="dir to write results to",
default="outputs/txt2img-samples"
)
parser.add_argument(
"--skip_grid",
action='store_true',
help="do not save a grid, only individual samples. Helpful when evaluating lots of samples",
)
parser.add_argument(
"--ddim_steps",
type=int,
default=50,
help="number of ddim sampling steps",
)
parser.add_argument(
"--n_repeat",
type=int,
default=1,
help="number of repeats in CLIP latent space",
)
parser.add_argument(
"--plms",
action='store_true',
help="use plms sampling",
)
parser.add_argument(
"--ddim_eta",
type=float,
default=0.0,
help="ddim eta (eta=0.0 corresponds to deterministic sampling",
)
parser.add_argument(
"--n_iter",
type=int,
default=1,
help="sample this often",
)
parser.add_argument(
"--H",
type=int,
default=768,
help="image height, in pixel space",
)
parser.add_argument(
"--W",
type=int,
default=768,
help="image width, in pixel space",
)
parser.add_argument(
"--n_samples",
type=int,
default=3,
help="how many samples to produce for each given prompt. A.k.a batch size",
)
parser.add_argument(
"--n_rows",
type=int,
default=0,
help="rows in the grid (default: n_samples)",
)
parser.add_argument(
"--scale",
type=float,
default=5.0,
help="unconditional guidance scale: eps = eps(x, empty) + scale * (eps(x, cond) - eps(x, empty))",
)
parser.add_argument(
"--from-file",
type=str,
help="if specified, load prompts from this file",
)
parser.add_argument(
"--config",
type=str,
default="configs/retrieval-augmented-diffusion/768x768.yaml",
help="path to config which constructs model",
)
parser.add_argument(
"--ckpt",
type=str,
default="models/rdm/rdm768x768/model.ckpt",
help="path to checkpoint of model",
)
parser.add_argument(
"--clip_type",
type=str,
default="ViT-L/14",
help="which CLIP model to use for retrieval and NN encoding",
)
parser.add_argument(
"--database",
type=str,
default='artbench-surrealism',
choices=DATABASES,
help="The database used for the search, only applied when --use_neighbors=True",
)
parser.add_argument(
"--use_neighbors",
default=False,
action='store_true',
help="Include neighbors in addition to text prompt for conditioning",
)
parser.add_argument(
"--knn",
default=10,
type=int,
help="The number of included neighbors, only applied when --use_neighbors=True",
)
opt = parser.parse_args()
config = OmegaConf.load(f"{opt.config}")
model = load_model_from_config(config, f"{opt.ckpt}")
device = torch.device("cuda") if torch.cuda.is_available() else torch.device("cpu")
model = model.to(device)
clip_text_encoder = FrozenCLIPTextEmbedder(opt.clip_type).to(device)
if opt.plms:
sampler = PLMSSampler(model)
else:
sampler = DDIMSampler(model)
os.makedirs(opt.outdir, exist_ok=True)
outpath = opt.outdir
batch_size = opt.n_samples
n_rows = opt.n_rows if opt.n_rows > 0 else batch_size
if not opt.from_file:
prompt = opt.prompt
assert prompt is not None
data = [batch_size * [prompt]]
else:
print(f"reading prompts from {opt.from_file}")
with open(opt.from_file, "r") as f:
data = f.read().splitlines()
data = list(chunk(data, batch_size))
sample_path = os.path.join(outpath, "samples")
os.makedirs(sample_path, exist_ok=True)
base_count = len(os.listdir(sample_path))
grid_count = len(os.listdir(outpath)) - 1
print(f"sampling scale for cfg is {opt.scale:.2f}")
searcher = None
if opt.use_neighbors:
searcher = Searcher(opt.database)
with torch.no_grad():
with model.ema_scope():
for n in trange(opt.n_iter, desc="Sampling"):
all_samples = list()
for prompts in tqdm(data, desc="data"):
print("sampling prompts:", prompts)
if isinstance(prompts, tuple):
prompts = list(prompts)
c = clip_text_encoder.encode(prompts)
uc = None
if searcher is not None:
nn_dict = searcher(c, opt.knn)
c = torch.cat([c, torch.from_numpy(nn_dict['nn_embeddings']).cuda()], dim=1)
if opt.scale != 1.0:
uc = torch.zeros_like(c)
if isinstance(prompts, tuple):
prompts = list(prompts)
shape = [16, opt.H // 16, opt.W // 16] # note: currently hardcoded for f16 model
samples_ddim, _ = sampler.sample(S=opt.ddim_steps,
conditioning=c,
batch_size=c.shape[0],
shape=shape,
verbose=False,
unconditional_guidance_scale=opt.scale,
unconditional_conditioning=uc,
eta=opt.ddim_eta,
)
x_samples_ddim = model.decode_first_stage(samples_ddim)
x_samples_ddim = torch.clamp((x_samples_ddim + 1.0) / 2.0, min=0.0, max=1.0)
for x_sample in x_samples_ddim:
x_sample = 255. * rearrange(x_sample.cpu().numpy(), 'c h w -> h w c')
Image.fromarray(x_sample.astype(np.uint8)).save(
os.path.join(sample_path, f"{base_count:05}.png"))
base_count += 1
all_samples.append(x_samples_ddim)
if not opt.skip_grid:
# additionally, save as grid
grid = torch.stack(all_samples, 0)
grid = rearrange(grid, 'n b c h w -> (n b) c h w')
grid = make_grid(grid, nrow=n_rows)
# to image
grid = 255. * rearrange(grid, 'c h w -> h w c').cpu().numpy()
Image.fromarray(grid.astype(np.uint8)).save(os.path.join(outpath, f'grid-{grid_count:04}.png'))
grid_count += 1
print(f"Your samples are ready and waiting for you here: \n{outpath} \nEnjoy.")
| EXA-1-master | exa/libraries/latent-diffusion/scripts/knn2img.py |
import argparse, os, sys, glob, datetime, yaml
import torch
import time
import numpy as np
from tqdm import trange
from omegaconf import OmegaConf
from PIL import Image
from ldm.models.diffusion.ddim import DDIMSampler
from ldm.util import instantiate_from_config
rescale = lambda x: (x + 1.) / 2.
def custom_to_pil(x):
x = x.detach().cpu()
x = torch.clamp(x, -1., 1.)
x = (x + 1.) / 2.
x = x.permute(1, 2, 0).numpy()
x = (255 * x).astype(np.uint8)
x = Image.fromarray(x)
if not x.mode == "RGB":
x = x.convert("RGB")
return x
def custom_to_np(x):
# saves the batch in adm style as in https://github.com/openai/guided-diffusion/blob/main/scripts/image_sample.py
sample = x.detach().cpu()
sample = ((sample + 1) * 127.5).clamp(0, 255).to(torch.uint8)
sample = sample.permute(0, 2, 3, 1)
sample = sample.contiguous()
return sample
def logs2pil(logs, keys=["sample"]):
imgs = dict()
for k in logs:
try:
if len(logs[k].shape) == 4:
img = custom_to_pil(logs[k][0, ...])
elif len(logs[k].shape) == 3:
img = custom_to_pil(logs[k])
else:
print(f"Unknown format for key {k}. ")
img = None
except:
img = None
imgs[k] = img
return imgs
@torch.no_grad()
def convsample(model, shape, return_intermediates=True,
verbose=True,
make_prog_row=False):
if not make_prog_row:
return model.p_sample_loop(None, shape,
return_intermediates=return_intermediates, verbose=verbose)
else:
return model.progressive_denoising(
None, shape, verbose=True
)
@torch.no_grad()
def convsample_ddim(model, steps, shape, eta=1.0
):
ddim = DDIMSampler(model)
bs = shape[0]
shape = shape[1:]
samples, intermediates = ddim.sample(steps, batch_size=bs, shape=shape, eta=eta, verbose=False,)
return samples, intermediates
@torch.no_grad()
def make_convolutional_sample(model, batch_size, vanilla=False, custom_steps=None, eta=1.0,):
log = dict()
shape = [batch_size,
model.model.diffusion_model.in_channels,
model.model.diffusion_model.image_size,
model.model.diffusion_model.image_size]
with model.ema_scope("Plotting"):
t0 = time.time()
if vanilla:
sample, progrow = convsample(model, shape,
make_prog_row=True)
else:
sample, intermediates = convsample_ddim(model, steps=custom_steps, shape=shape,
eta=eta)
t1 = time.time()
x_sample = model.decode_first_stage(sample)
log["sample"] = x_sample
log["time"] = t1 - t0
log['throughput'] = sample.shape[0] / (t1 - t0)
print(f'Throughput for this batch: {log["throughput"]}')
return log
def run(model, logdir, batch_size=50, vanilla=False, custom_steps=None, eta=None, n_samples=50000, nplog=None):
if vanilla:
print(f'Using Vanilla DDPM sampling with {model.num_timesteps} sampling steps.')
else:
print(f'Using DDIM sampling with {custom_steps} sampling steps and eta={eta}')
tstart = time.time()
n_saved = len(glob.glob(os.path.join(logdir,'*.png')))-1
# path = logdir
if model.cond_stage_model is None:
all_images = []
print(f"Running unconditional sampling for {n_samples} samples")
for _ in trange(n_samples // batch_size, desc="Sampling Batches (unconditional)"):
logs = make_convolutional_sample(model, batch_size=batch_size,
vanilla=vanilla, custom_steps=custom_steps,
eta=eta)
n_saved = save_logs(logs, logdir, n_saved=n_saved, key="sample")
all_images.extend([custom_to_np(logs["sample"])])
if n_saved >= n_samples:
print(f'Finish after generating {n_saved} samples')
break
all_img = np.concatenate(all_images, axis=0)
all_img = all_img[:n_samples]
shape_str = "x".join([str(x) for x in all_img.shape])
nppath = os.path.join(nplog, f"{shape_str}-samples.npz")
np.savez(nppath, all_img)
else:
raise NotImplementedError('Currently only sampling for unconditional models supported.')
print(f"sampling of {n_saved} images finished in {(time.time() - tstart) / 60.:.2f} minutes.")
def save_logs(logs, path, n_saved=0, key="sample", np_path=None):
for k in logs:
if k == key:
batch = logs[key]
if np_path is None:
for x in batch:
img = custom_to_pil(x)
imgpath = os.path.join(path, f"{key}_{n_saved:06}.png")
img.save(imgpath)
n_saved += 1
else:
npbatch = custom_to_np(batch)
shape_str = "x".join([str(x) for x in npbatch.shape])
nppath = os.path.join(np_path, f"{n_saved}-{shape_str}-samples.npz")
np.savez(nppath, npbatch)
n_saved += npbatch.shape[0]
return n_saved
def get_parser():
parser = argparse.ArgumentParser()
parser.add_argument(
"-r",
"--resume",
type=str,
nargs="?",
help="load from logdir or checkpoint in logdir",
)
parser.add_argument(
"-n",
"--n_samples",
type=int,
nargs="?",
help="number of samples to draw",
default=50000
)
parser.add_argument(
"-e",
"--eta",
type=float,
nargs="?",
help="eta for ddim sampling (0.0 yields deterministic sampling)",
default=1.0
)
parser.add_argument(
"-v",
"--vanilla_sample",
default=False,
action='store_true',
help="vanilla sampling (default option is DDIM sampling)?",
)
parser.add_argument(
"-l",
"--logdir",
type=str,
nargs="?",
help="extra logdir",
default="none"
)
parser.add_argument(
"-c",
"--custom_steps",
type=int,
nargs="?",
help="number of steps for ddim and fastdpm sampling",
default=50
)
parser.add_argument(
"--batch_size",
type=int,
nargs="?",
help="the bs",
default=10
)
return parser
def load_model_from_config(config, sd):
model = instantiate_from_config(config)
model.load_state_dict(sd,strict=False)
model.cuda()
model.eval()
return model
def load_model(config, ckpt, gpu, eval_mode):
if ckpt:
print(f"Loading model from {ckpt}")
pl_sd = torch.load(ckpt, map_location="cpu")
global_step = pl_sd["global_step"]
else:
pl_sd = {"state_dict": None}
global_step = None
model = load_model_from_config(config.model,
pl_sd["state_dict"])
return model, global_step
if __name__ == "__main__":
now = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
sys.path.append(os.getcwd())
command = " ".join(sys.argv)
parser = get_parser()
opt, unknown = parser.parse_known_args()
ckpt = None
if not os.path.exists(opt.resume):
raise ValueError("Cannot find {}".format(opt.resume))
if os.path.isfile(opt.resume):
# paths = opt.resume.split("/")
try:
logdir = '/'.join(opt.resume.split('/')[:-1])
# idx = len(paths)-paths[::-1].index("logs")+1
print(f'Logdir is {logdir}')
except ValueError:
paths = opt.resume.split("/")
idx = -2 # take a guess: path/to/logdir/checkpoints/model.ckpt
logdir = "/".join(paths[:idx])
ckpt = opt.resume
else:
assert os.path.isdir(opt.resume), f"{opt.resume} is not a directory"
logdir = opt.resume.rstrip("/")
ckpt = os.path.join(logdir, "model.ckpt")
base_configs = sorted(glob.glob(os.path.join(logdir, "config.yaml")))
opt.base = base_configs
configs = [OmegaConf.load(cfg) for cfg in opt.base]
cli = OmegaConf.from_dotlist(unknown)
config = OmegaConf.merge(*configs, cli)
gpu = True
eval_mode = True
if opt.logdir != "none":
locallog = logdir.split(os.sep)[-1]
if locallog == "": locallog = logdir.split(os.sep)[-2]
print(f"Switching logdir from '{logdir}' to '{os.path.join(opt.logdir, locallog)}'")
logdir = os.path.join(opt.logdir, locallog)
print(config)
model, global_step = load_model(config, ckpt, gpu, eval_mode)
print(f"global step: {global_step}")
print(75 * "=")
print("logging to:")
logdir = os.path.join(logdir, "samples", f"{global_step:08}", now)
imglogdir = os.path.join(logdir, "img")
numpylogdir = os.path.join(logdir, "numpy")
os.makedirs(imglogdir)
os.makedirs(numpylogdir)
print(logdir)
print(75 * "=")
# write config out
sampling_file = os.path.join(logdir, "sampling_config.yaml")
sampling_conf = vars(opt)
with open(sampling_file, 'w') as f:
yaml.dump(sampling_conf, f, default_flow_style=False)
print(sampling_conf)
run(model, imglogdir, eta=opt.eta,
vanilla=opt.vanilla_sample, n_samples=opt.n_samples, custom_steps=opt.custom_steps,
batch_size=opt.batch_size, nplog=numpylogdir)
print("done.")
| EXA-1-master | exa/libraries/latent-diffusion/scripts/sample_diffusion.py |
import os, sys
import numpy as np
import scann
import argparse
import glob
from multiprocessing import cpu_count
from tqdm import tqdm
from ldm.util import parallel_data_prefetch
def search_bruteforce(searcher):
return searcher.score_brute_force().build()
def search_partioned_ah(searcher, dims_per_block, aiq_threshold, reorder_k,
partioning_trainsize, num_leaves, num_leaves_to_search):
return searcher.tree(num_leaves=num_leaves,
num_leaves_to_search=num_leaves_to_search,
training_sample_size=partioning_trainsize). \
score_ah(dims_per_block, anisotropic_quantization_threshold=aiq_threshold).reorder(reorder_k).build()
def search_ah(searcher, dims_per_block, aiq_threshold, reorder_k):
return searcher.score_ah(dims_per_block, anisotropic_quantization_threshold=aiq_threshold).reorder(
reorder_k).build()
def load_datapool(dpath):
def load_single_file(saved_embeddings):
compressed = np.load(saved_embeddings)
database = {key: compressed[key] for key in compressed.files}
return database
def load_multi_files(data_archive):
database = {key: [] for key in data_archive[0].files}
for d in tqdm(data_archive, desc=f'Loading datapool from {len(data_archive)} individual files.'):
for key in d.files:
database[key].append(d[key])
return database
print(f'Load saved patch embedding from "{dpath}"')
file_content = glob.glob(os.path.join(dpath, '*.npz'))
if len(file_content) == 1:
data_pool = load_single_file(file_content[0])
elif len(file_content) > 1:
data = [np.load(f) for f in file_content]
prefetched_data = parallel_data_prefetch(load_multi_files, data,
n_proc=min(len(data), cpu_count()), target_data_type='dict')
data_pool = {key: np.concatenate([od[key] for od in prefetched_data], axis=1)[0] for key in prefetched_data[0].keys()}
else:
raise ValueError(f'No npz-files in specified path "{dpath}" is this directory existing?')
print(f'Finished loading of retrieval database of length {data_pool["embedding"].shape[0]}.')
return data_pool
def train_searcher(opt,
metric='dot_product',
partioning_trainsize=None,
reorder_k=None,
# todo tune
aiq_thld=0.2,
dims_per_block=2,
num_leaves=None,
num_leaves_to_search=None,):
data_pool = load_datapool(opt.database)
k = opt.knn
if not reorder_k:
reorder_k = 2 * k
# normalize
# embeddings =
searcher = scann.scann_ops_pybind.builder(data_pool['embedding'] / np.linalg.norm(data_pool['embedding'], axis=1)[:, np.newaxis], k, metric)
pool_size = data_pool['embedding'].shape[0]
print(*(['#'] * 100))
print('Initializing scaNN searcher with the following values:')
print(f'k: {k}')
print(f'metric: {metric}')
print(f'reorder_k: {reorder_k}')
print(f'anisotropic_quantization_threshold: {aiq_thld}')
print(f'dims_per_block: {dims_per_block}')
print(*(['#'] * 100))
print('Start training searcher....')
print(f'N samples in pool is {pool_size}')
# this reflects the recommended design choices proposed at
# https://github.com/google-research/google-research/blob/aca5f2e44e301af172590bb8e65711f0c9ee0cfd/scann/docs/algorithms.md
if pool_size < 2e4:
print('Using brute force search.')
searcher = search_bruteforce(searcher)
elif 2e4 <= pool_size and pool_size < 1e5:
print('Using asymmetric hashing search and reordering.')
searcher = search_ah(searcher, dims_per_block, aiq_thld, reorder_k)
else:
print('Using using partioning, asymmetric hashing search and reordering.')
if not partioning_trainsize:
partioning_trainsize = data_pool['embedding'].shape[0] // 10
if not num_leaves:
num_leaves = int(np.sqrt(pool_size))
if not num_leaves_to_search:
num_leaves_to_search = max(num_leaves // 20, 1)
print('Partitioning params:')
print(f'num_leaves: {num_leaves}')
print(f'num_leaves_to_search: {num_leaves_to_search}')
# self.searcher = self.search_ah(searcher, dims_per_block, aiq_thld, reorder_k)
searcher = search_partioned_ah(searcher, dims_per_block, aiq_thld, reorder_k,
partioning_trainsize, num_leaves, num_leaves_to_search)
print('Finish training searcher')
searcher_savedir = opt.target_path
os.makedirs(searcher_savedir, exist_ok=True)
searcher.serialize(searcher_savedir)
print(f'Saved trained searcher under "{searcher_savedir}"')
if __name__ == '__main__':
sys.path.append(os.getcwd())
parser = argparse.ArgumentParser()
parser.add_argument('--database',
'-d',
default='data/rdm/retrieval_databases/openimages',
type=str,
help='path to folder containing the clip feature of the database')
parser.add_argument('--target_path',
'-t',
default='data/rdm/searchers/openimages',
type=str,
help='path to the target folder where the searcher shall be stored.')
parser.add_argument('--knn',
'-k',
default=20,
type=int,
help='number of nearest neighbors, for which the searcher shall be optimized')
opt, _ = parser.parse_known_args()
train_searcher(opt,) | EXA-1-master | exa/libraries/latent-diffusion/scripts/train_searcher.py |
import numpy as np
class LambdaWarmUpCosineScheduler:
"""
note: use with a base_lr of 1.0
"""
def __init__(self, warm_up_steps, lr_min, lr_max, lr_start, max_decay_steps, verbosity_interval=0):
self.lr_warm_up_steps = warm_up_steps
self.lr_start = lr_start
self.lr_min = lr_min
self.lr_max = lr_max
self.lr_max_decay_steps = max_decay_steps
self.last_lr = 0.
self.verbosity_interval = verbosity_interval
def schedule(self, n, **kwargs):
if self.verbosity_interval > 0:
if n % self.verbosity_interval == 0: print(f"current step: {n}, recent lr-multiplier: {self.last_lr}")
if n < self.lr_warm_up_steps:
lr = (self.lr_max - self.lr_start) / self.lr_warm_up_steps * n + self.lr_start
self.last_lr = lr
return lr
else:
t = (n - self.lr_warm_up_steps) / (self.lr_max_decay_steps - self.lr_warm_up_steps)
t = min(t, 1.0)
lr = self.lr_min + 0.5 * (self.lr_max - self.lr_min) * (
1 + np.cos(t * np.pi))
self.last_lr = lr
return lr
def __call__(self, n, **kwargs):
return self.schedule(n,**kwargs)
class LambdaWarmUpCosineScheduler2:
"""
supports repeated iterations, configurable via lists
note: use with a base_lr of 1.0.
"""
def __init__(self, warm_up_steps, f_min, f_max, f_start, cycle_lengths, verbosity_interval=0):
assert len(warm_up_steps) == len(f_min) == len(f_max) == len(f_start) == len(cycle_lengths)
self.lr_warm_up_steps = warm_up_steps
self.f_start = f_start
self.f_min = f_min
self.f_max = f_max
self.cycle_lengths = cycle_lengths
self.cum_cycles = np.cumsum([0] + list(self.cycle_lengths))
self.last_f = 0.
self.verbosity_interval = verbosity_interval
def find_in_interval(self, n):
interval = 0
for cl in self.cum_cycles[1:]:
if n <= cl:
return interval
interval += 1
def schedule(self, n, **kwargs):
cycle = self.find_in_interval(n)
n = n - self.cum_cycles[cycle]
if self.verbosity_interval > 0:
if n % self.verbosity_interval == 0: print(f"current step: {n}, recent lr-multiplier: {self.last_f}, "
f"current cycle {cycle}")
if n < self.lr_warm_up_steps[cycle]:
f = (self.f_max[cycle] - self.f_start[cycle]) / self.lr_warm_up_steps[cycle] * n + self.f_start[cycle]
self.last_f = f
return f
else:
t = (n - self.lr_warm_up_steps[cycle]) / (self.cycle_lengths[cycle] - self.lr_warm_up_steps[cycle])
t = min(t, 1.0)
f = self.f_min[cycle] + 0.5 * (self.f_max[cycle] - self.f_min[cycle]) * (
1 + np.cos(t * np.pi))
self.last_f = f
return f
def __call__(self, n, **kwargs):
return self.schedule(n, **kwargs)
class LambdaLinearScheduler(LambdaWarmUpCosineScheduler2):
def schedule(self, n, **kwargs):
cycle = self.find_in_interval(n)
n = n - self.cum_cycles[cycle]
if self.verbosity_interval > 0:
if n % self.verbosity_interval == 0: print(f"current step: {n}, recent lr-multiplier: {self.last_f}, "
f"current cycle {cycle}")
if n < self.lr_warm_up_steps[cycle]:
f = (self.f_max[cycle] - self.f_start[cycle]) / self.lr_warm_up_steps[cycle] * n + self.f_start[cycle]
self.last_f = f
return f
else:
f = self.f_min[cycle] + (self.f_max[cycle] - self.f_min[cycle]) * (self.cycle_lengths[cycle] - n) / (self.cycle_lengths[cycle])
self.last_f = f
return f
| EXA-1-master | exa/libraries/latent-diffusion/ldm/lr_scheduler.py |
import importlib
import torch
import numpy as np
from collections import abc
from einops import rearrange
from functools import partial
import multiprocessing as mp
from threading import Thread
from queue import Queue
from inspect import isfunction
from PIL import Image, ImageDraw, ImageFont
def log_txt_as_img(wh, xc, size=10):
# wh a tuple of (width, height)
# xc a list of captions to plot
b = len(xc)
txts = list()
for bi in range(b):
txt = Image.new("RGB", wh, color="white")
draw = ImageDraw.Draw(txt)
font = ImageFont.truetype('data/DejaVuSans.ttf', size=size)
nc = int(40 * (wh[0] / 256))
lines = "\n".join(xc[bi][start:start + nc] for start in range(0, len(xc[bi]), nc))
try:
draw.text((0, 0), lines, fill="black", font=font)
except UnicodeEncodeError:
print("Cant encode string for logging. Skipping.")
txt = np.array(txt).transpose(2, 0, 1) / 127.5 - 1.0
txts.append(txt)
txts = np.stack(txts)
txts = torch.tensor(txts)
return txts
def ismap(x):
if not isinstance(x, torch.Tensor):
return False
return (len(x.shape) == 4) and (x.shape[1] > 3)
def isimage(x):
if not isinstance(x, torch.Tensor):
return False
return (len(x.shape) == 4) and (x.shape[1] == 3 or x.shape[1] == 1)
def exists(x):
return x is not None
def default(val, d):
if exists(val):
return val
return d() if isfunction(d) else d
def mean_flat(tensor):
"""
https://github.com/openai/guided-diffusion/blob/27c20a8fab9cb472df5d6bdd6c8d11c8f430b924/guided_diffusion/nn.py#L86
Take the mean over all non-batch dimensions.
"""
return tensor.mean(dim=list(range(1, len(tensor.shape))))
def count_params(model, verbose=False):
total_params = sum(p.numel() for p in model.parameters())
if verbose:
print(f"{model.__class__.__name__} has {total_params * 1.e-6:.2f} M params.")
return total_params
def instantiate_from_config(config):
if not "target" in config:
if config == '__is_first_stage__':
return None
elif config == "__is_unconditional__":
return None
raise KeyError("Expected key `target` to instantiate.")
return get_obj_from_str(config["target"])(**config.get("params", dict()))
def get_obj_from_str(string, reload=False):
module, cls = string.rsplit(".", 1)
if reload:
module_imp = importlib.import_module(module)
importlib.reload(module_imp)
return getattr(importlib.import_module(module, package=None), cls)
def _do_parallel_data_prefetch(func, Q, data, idx, idx_to_fn=False):
# create dummy dataset instance
# run prefetching
if idx_to_fn:
res = func(data, worker_id=idx)
else:
res = func(data)
Q.put([idx, res])
Q.put("Done")
def parallel_data_prefetch(
func: callable, data, n_proc, target_data_type="ndarray", cpu_intensive=True, use_worker_id=False
):
# if target_data_type not in ["ndarray", "list"]:
# raise ValueError(
# "Data, which is passed to parallel_data_prefetch has to be either of type list or ndarray."
# )
if isinstance(data, np.ndarray) and target_data_type == "list":
raise ValueError("list expected but function got ndarray.")
elif isinstance(data, abc.Iterable):
if isinstance(data, dict):
print(
f'WARNING:"data" argument passed to parallel_data_prefetch is a dict: Using only its values and disregarding keys.'
)
data = list(data.values())
if target_data_type == "ndarray":
data = np.asarray(data)
else:
data = list(data)
else:
raise TypeError(
f"The data, that shall be processed parallel has to be either an np.ndarray or an Iterable, but is actually {type(data)}."
)
if cpu_intensive:
Q = mp.Queue(1000)
proc = mp.Process
else:
Q = Queue(1000)
proc = Thread
# spawn processes
if target_data_type == "ndarray":
arguments = [
[func, Q, part, i, use_worker_id]
for i, part in enumerate(np.array_split(data, n_proc))
]
else:
step = (
int(len(data) / n_proc + 1)
if len(data) % n_proc != 0
else int(len(data) / n_proc)
)
arguments = [
[func, Q, part, i, use_worker_id]
for i, part in enumerate(
[data[i: i + step] for i in range(0, len(data), step)]
)
]
processes = []
for i in range(n_proc):
p = proc(target=_do_parallel_data_prefetch, args=arguments[i])
processes += [p]
# start processes
print(f"Start prefetching...")
import time
start = time.time()
gather_res = [[] for _ in range(n_proc)]
try:
for p in processes:
p.start()
k = 0
while k < n_proc:
# get result
res = Q.get()
if res == "Done":
k += 1
else:
gather_res[res[0]] = res[1]
except Exception as e:
print("Exception: ", e)
for p in processes:
p.terminate()
raise e
finally:
for p in processes:
p.join()
print(f"Prefetching complete. [{time.time() - start} sec.]")
if target_data_type == 'ndarray':
if not isinstance(gather_res[0], np.ndarray):
return np.concatenate([np.asarray(r) for r in gather_res], axis=0)
# order outputs
return np.concatenate(gather_res, axis=0)
elif target_data_type == 'list':
out = []
for r in gather_res:
out.extend(r)
return out
else:
return gather_res
| EXA-1-master | exa/libraries/latent-diffusion/ldm/util.py |
import torch
import pytorch_lightning as pl
import torch.nn.functional as F
from contextlib import contextmanager
from taming.modules.vqvae.quantize import VectorQuantizer2 as VectorQuantizer
from ldm.modules.diffusionmodules.model import Encoder, Decoder
from ldm.modules.distributions.distributions import DiagonalGaussianDistribution
from ldm.util import instantiate_from_config
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,
batch_resize_range=None,
scheduler_config=None,
lr_g_factor=1.0,
remap=None,
sane_index_shape=False, # tell vector quantizer to return indices as bhw
use_ema=False
):
super().__init__()
self.embed_dim = embed_dim
self.n_embed = n_embed
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 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
self.batch_resize_range = batch_resize_range
if self.batch_resize_range is not None:
print(f"{self.__class__.__name__}: Using per-batch resizing in range {batch_resize_range}.")
self.use_ema = use_ema
if self.use_ema:
self.model_ema = LitEma(self)
print(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.")
if ckpt_path is not None:
self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
self.scheduler_config = scheduler_config
self.lr_g_factor = lr_g_factor
@contextmanager
def ema_scope(self, context=None):
if self.use_ema:
self.model_ema.store(self.parameters())
self.model_ema.copy_to(self)
if context is not None:
print(f"{context}: Switched to EMA weights")
try:
yield None
finally:
if self.use_ema:
self.model_ema.restore(self.parameters())
if context is not None:
print(f"{context}: Restored training weights")
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]
missing, unexpected = self.load_state_dict(sd, strict=False)
print(f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys")
if len(missing) > 0:
print(f"Missing Keys: {missing}")
print(f"Unexpected Keys: {unexpected}")
def on_train_batch_end(self, *args, **kwargs):
if self.use_ema:
self.model_ema(self)
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 encode_to_prequant(self, x):
h = self.encoder(x)
h = self.quant_conv(h)
return h
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, return_pred_indices=False):
quant, diff, (_,_,ind) = self.encode(input)
dec = self.decode(quant)
if return_pred_indices:
return dec, diff, ind
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).float()
if self.batch_resize_range is not None:
lower_size = self.batch_resize_range[0]
upper_size = self.batch_resize_range[1]
if self.global_step <= 4:
# do the first few batches with max size to avoid later oom
new_resize = upper_size
else:
new_resize = np.random.choice(np.arange(lower_size, upper_size+16, 16))
if new_resize != x.shape[2]:
x = F.interpolate(x, size=new_resize, mode="bicubic")
x = x.detach()
return x
def training_step(self, batch, batch_idx, optimizer_idx):
# https://github.com/pytorch/pytorch/issues/37142
# try not to fool the heuristics
x = self.get_input(batch, self.image_key)
xrec, qloss, ind = self(x, return_pred_indices=True)
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",
predicted_indices=ind)
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_dict(log_dict_disc, prog_bar=False, logger=True, on_step=True, on_epoch=True)
return discloss
def validation_step(self, batch, batch_idx):
log_dict = self._validation_step(batch, batch_idx)
with self.ema_scope():
log_dict_ema = self._validation_step(batch, batch_idx, suffix="_ema")
return log_dict
def _validation_step(self, batch, batch_idx, suffix=""):
x = self.get_input(batch, self.image_key)
xrec, qloss, ind = 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"+suffix,
predicted_indices=ind
)
discloss, log_dict_disc = self.loss(qloss, x, xrec, 1,
self.global_step,
last_layer=self.get_last_layer(),
split="val"+suffix,
predicted_indices=ind
)
rec_loss = log_dict_ae[f"val{suffix}/rec_loss"]
self.log(f"val{suffix}/rec_loss", rec_loss,
prog_bar=True, logger=True, on_step=False, on_epoch=True, sync_dist=True)
self.log(f"val{suffix}/aeloss", aeloss,
prog_bar=True, logger=True, on_step=False, on_epoch=True, sync_dist=True)
if version.parse(pl.__version__) >= version.parse('1.4.0'):
del log_dict_ae[f"val{suffix}/rec_loss"]
self.log_dict(log_dict_ae)
self.log_dict(log_dict_disc)
return self.log_dict
def configure_optimizers(self):
lr_d = self.learning_rate
lr_g = self.lr_g_factor*self.learning_rate
print("lr_d", lr_d)
print("lr_g", lr_g)
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_g, betas=(0.5, 0.9))
opt_disc = torch.optim.Adam(self.loss.discriminator.parameters(),
lr=lr_d, betas=(0.5, 0.9))
if self.scheduler_config is not None:
scheduler = instantiate_from_config(self.scheduler_config)
print("Setting up LambdaLR scheduler...")
scheduler = [
{
'scheduler': LambdaLR(opt_ae, lr_lambda=scheduler.schedule),
'interval': 'step',
'frequency': 1
},
{
'scheduler': LambdaLR(opt_disc, lr_lambda=scheduler.schedule),
'interval': 'step',
'frequency': 1
},
]
return [opt_ae, opt_disc], scheduler
return [opt_ae, opt_disc], []
def get_last_layer(self):
return self.decoder.conv_out.weight
def log_images(self, batch, only_inputs=False, plot_ema=False, **kwargs):
log = dict()
x = self.get_input(batch, self.image_key)
x = x.to(self.device)
if only_inputs:
log["inputs"] = x
return log
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
if plot_ema:
with self.ema_scope():
xrec_ema, _ = self(x)
if x.shape[1] > 3: xrec_ema = self.to_rgb(xrec_ema)
log["reconstructions_ema"] = xrec_ema
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 VQModelInterface(VQModel):
def __init__(self, embed_dim, *args, **kwargs):
super().__init__(embed_dim=embed_dim, *args, **kwargs)
self.embed_dim = embed_dim
def encode(self, x):
h = self.encoder(x)
h = self.quant_conv(h)
return h
def decode(self, h, force_not_quantize=False):
# also go through quantization layer
if not force_not_quantize:
quant, emb_loss, info = self.quantize(h)
else:
quant = h
quant = self.post_quant_conv(quant)
dec = self.decoder(quant)
return dec
class AutoencoderKL(pl.LightningModule):
def __init__(self,
ddconfig,
lossconfig,
embed_dim,
ckpt_path=None,
ignore_keys=[],
image_key="image",
colorize_nlabels=None,
monitor=None,
):
super().__init__()
self.image_key = image_key
self.encoder = Encoder(**ddconfig)
self.decoder = Decoder(**ddconfig)
self.loss = instantiate_from_config(lossconfig)
assert ddconfig["double_z"]
self.quant_conv = torch.nn.Conv2d(2*ddconfig["z_channels"], 2*embed_dim, 1)
self.post_quant_conv = torch.nn.Conv2d(embed_dim, ddconfig["z_channels"], 1)
self.embed_dim = embed_dim
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
if ckpt_path is not None:
self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys)
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)
moments = self.quant_conv(h)
posterior = DiagonalGaussianDistribution(moments)
return posterior
def decode(self, z):
z = self.post_quant_conv(z)
dec = self.decoder(z)
return dec
def forward(self, input, sample_posterior=True):
posterior = self.encode(input)
if sample_posterior:
z = posterior.sample()
else:
z = posterior.mode()
dec = self.decode(z)
return dec, posterior
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).float()
return x
def training_step(self, batch, batch_idx, optimizer_idx):
inputs = self.get_input(batch, self.image_key)
reconstructions, posterior = self(inputs)
if optimizer_idx == 0:
# train encoder+decoder+logvar
aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
last_layer=self.get_last_layer(), split="train")
self.log("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=False)
return aeloss
if optimizer_idx == 1:
# train the discriminator
discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, optimizer_idx, self.global_step,
last_layer=self.get_last_layer(), split="train")
self.log("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=False)
return discloss
def validation_step(self, batch, batch_idx):
inputs = self.get_input(batch, self.image_key)
reconstructions, posterior = self(inputs)
aeloss, log_dict_ae = self.loss(inputs, reconstructions, posterior, 0, self.global_step,
last_layer=self.get_last_layer(), split="val")
discloss, log_dict_disc = self.loss(inputs, reconstructions, posterior, 1, self.global_step,
last_layer=self.get_last_layer(), split="val")
self.log("val/rec_loss", log_dict_ae["val/rec_loss"])
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.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
@torch.no_grad()
def log_images(self, batch, only_inputs=False, **kwargs):
log = dict()
x = self.get_input(batch, self.image_key)
x = x.to(self.device)
if not only_inputs:
xrec, posterior = 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["samples"] = self.decode(torch.randn_like(posterior.sample()))
log["reconstructions"] = xrec
log["inputs"] = x
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 IdentityFirstStage(torch.nn.Module):
def __init__(self, *args, vq_interface=False, **kwargs):
self.vq_interface = vq_interface # TODO: Should be true by default but check to not break older stuff
super().__init__()
def encode(self, x, *args, **kwargs):
return x
def decode(self, x, *args, **kwargs):
return x
def quantize(self, x, *args, **kwargs):
if self.vq_interface:
return x, None, [None, None, None]
return x
def forward(self, x, *args, **kwargs):
return x
| EXA-1-master | exa/libraries/latent-diffusion/ldm/models/autoencoder.py |
"""SAMPLING ONLY."""
import torch
import numpy as np
from tqdm import tqdm
from functools import partial
from ldm.modules.diffusionmodules.util import make_ddim_sampling_parameters, make_ddim_timesteps, noise_like
class DDIMSampler(object):
def __init__(self, model, schedule="linear", **kwargs):
super().__init__()
self.model = model
self.ddpm_num_timesteps = model.num_timesteps
self.schedule = schedule
def register_buffer(self, name, attr):
if type(attr) == torch.Tensor:
if attr.device != torch.device("cuda"):
attr = attr.to(torch.device("cuda"))
setattr(self, name, attr)
def make_schedule(self, ddim_num_steps, ddim_discretize="uniform", ddim_eta=0., verbose=True):
self.ddim_timesteps = make_ddim_timesteps(ddim_discr_method=ddim_discretize, num_ddim_timesteps=ddim_num_steps,
num_ddpm_timesteps=self.ddpm_num_timesteps,verbose=verbose)
alphas_cumprod = self.model.alphas_cumprod
assert alphas_cumprod.shape[0] == self.ddpm_num_timesteps, 'alphas have to be defined for each timestep'
to_torch = lambda x: x.clone().detach().to(torch.float32).to(self.model.device)
self.register_buffer('betas', to_torch(self.model.betas))
self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod))
self.register_buffer('alphas_cumprod_prev', to_torch(self.model.alphas_cumprod_prev))
# calculations for diffusion q(x_t | x_{t-1}) and others
self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod.cpu())))
self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod.cpu())))
self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod.cpu())))
self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu())))
self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu() - 1)))
# ddim sampling parameters
ddim_sigmas, ddim_alphas, ddim_alphas_prev = make_ddim_sampling_parameters(alphacums=alphas_cumprod.cpu(),
ddim_timesteps=self.ddim_timesteps,
eta=ddim_eta,verbose=verbose)
self.register_buffer('ddim_sigmas', ddim_sigmas)
self.register_buffer('ddim_alphas', ddim_alphas)
self.register_buffer('ddim_alphas_prev', ddim_alphas_prev)
self.register_buffer('ddim_sqrt_one_minus_alphas', np.sqrt(1. - ddim_alphas))
sigmas_for_original_sampling_steps = ddim_eta * torch.sqrt(
(1 - self.alphas_cumprod_prev) / (1 - self.alphas_cumprod) * (
1 - self.alphas_cumprod / self.alphas_cumprod_prev))
self.register_buffer('ddim_sigmas_for_original_num_steps', sigmas_for_original_sampling_steps)
@torch.no_grad()
def sample(self,
S,
batch_size,
shape,
conditioning=None,
callback=None,
normals_sequence=None,
img_callback=None,
quantize_x0=False,
eta=0.,
mask=None,
x0=None,
temperature=1.,
noise_dropout=0.,
score_corrector=None,
corrector_kwargs=None,
verbose=True,
x_T=None,
log_every_t=100,
unconditional_guidance_scale=1.,
unconditional_conditioning=None,
# this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...
**kwargs
):
if conditioning is not None:
if isinstance(conditioning, dict):
cbs = conditioning[list(conditioning.keys())[0]].shape[0]
if cbs != batch_size:
print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}")
else:
if conditioning.shape[0] != batch_size:
print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}")
self.make_schedule(ddim_num_steps=S, ddim_eta=eta, verbose=verbose)
# sampling
C, H, W = shape
size = (batch_size, C, H, W)
print(f'Data shape for DDIM sampling is {size}, eta {eta}')
samples, intermediates = self.ddim_sampling(conditioning, size,
callback=callback,
img_callback=img_callback,
quantize_denoised=quantize_x0,
mask=mask, x0=x0,
ddim_use_original_steps=False,
noise_dropout=noise_dropout,
temperature=temperature,
score_corrector=score_corrector,
corrector_kwargs=corrector_kwargs,
x_T=x_T,
log_every_t=log_every_t,
unconditional_guidance_scale=unconditional_guidance_scale,
unconditional_conditioning=unconditional_conditioning,
)
return samples, intermediates
@torch.no_grad()
def ddim_sampling(self, cond, shape,
x_T=None, ddim_use_original_steps=False,
callback=None, timesteps=None, quantize_denoised=False,
mask=None, x0=None, img_callback=None, log_every_t=100,
temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,
unconditional_guidance_scale=1., unconditional_conditioning=None,):
device = self.model.betas.device
b = shape[0]
if x_T is None:
img = torch.randn(shape, device=device)
else:
img = x_T
if timesteps is None:
timesteps = self.ddpm_num_timesteps if ddim_use_original_steps else self.ddim_timesteps
elif timesteps is not None and not ddim_use_original_steps:
subset_end = int(min(timesteps / self.ddim_timesteps.shape[0], 1) * self.ddim_timesteps.shape[0]) - 1
timesteps = self.ddim_timesteps[:subset_end]
intermediates = {'x_inter': [img], 'pred_x0': [img]}
time_range = reversed(range(0,timesteps)) if ddim_use_original_steps else np.flip(timesteps)
total_steps = timesteps if ddim_use_original_steps else timesteps.shape[0]
print(f"Running DDIM Sampling with {total_steps} timesteps")
iterator = tqdm(time_range, desc='DDIM Sampler', total=total_steps)
for i, step in enumerate(iterator):
index = total_steps - i - 1
ts = torch.full((b,), step, device=device, dtype=torch.long)
if mask is not None:
assert x0 is not None
img_orig = self.model.q_sample(x0, ts) # TODO: deterministic forward pass?
img = img_orig * mask + (1. - mask) * img
outs = self.p_sample_ddim(img, cond, ts, index=index, use_original_steps=ddim_use_original_steps,
quantize_denoised=quantize_denoised, temperature=temperature,
noise_dropout=noise_dropout, score_corrector=score_corrector,
corrector_kwargs=corrector_kwargs,
unconditional_guidance_scale=unconditional_guidance_scale,
unconditional_conditioning=unconditional_conditioning)
img, pred_x0 = outs
if callback: callback(i)
if img_callback: img_callback(pred_x0, i)
if index % log_every_t == 0 or index == total_steps - 1:
intermediates['x_inter'].append(img)
intermediates['pred_x0'].append(pred_x0)
return img, intermediates
@torch.no_grad()
def p_sample_ddim(self, x, c, t, index, repeat_noise=False, use_original_steps=False, quantize_denoised=False,
temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,
unconditional_guidance_scale=1., unconditional_conditioning=None):
b, *_, device = *x.shape, x.device
if unconditional_conditioning is None or unconditional_guidance_scale == 1.:
e_t = self.model.apply_model(x, t, c)
else:
x_in = torch.cat([x] * 2)
t_in = torch.cat([t] * 2)
c_in = torch.cat([unconditional_conditioning, c])
e_t_uncond, e_t = self.model.apply_model(x_in, t_in, c_in).chunk(2)
e_t = e_t_uncond + unconditional_guidance_scale * (e_t - e_t_uncond)
if score_corrector is not None:
assert self.model.parameterization == "eps"
e_t = score_corrector.modify_score(self.model, e_t, x, t, c, **corrector_kwargs)
alphas = self.model.alphas_cumprod if use_original_steps else self.ddim_alphas
alphas_prev = self.model.alphas_cumprod_prev if use_original_steps else self.ddim_alphas_prev
sqrt_one_minus_alphas = self.model.sqrt_one_minus_alphas_cumprod if use_original_steps else self.ddim_sqrt_one_minus_alphas
sigmas = self.model.ddim_sigmas_for_original_num_steps if use_original_steps else self.ddim_sigmas
# select parameters corresponding to the currently considered timestep
a_t = torch.full((b, 1, 1, 1), alphas[index], device=device)
a_prev = torch.full((b, 1, 1, 1), alphas_prev[index], device=device)
sigma_t = torch.full((b, 1, 1, 1), sigmas[index], device=device)
sqrt_one_minus_at = torch.full((b, 1, 1, 1), sqrt_one_minus_alphas[index],device=device)
# current prediction for x_0
pred_x0 = (x - sqrt_one_minus_at * e_t) / a_t.sqrt()
if quantize_denoised:
pred_x0, _, *_ = self.model.first_stage_model.quantize(pred_x0)
# direction pointing to x_t
dir_xt = (1. - a_prev - sigma_t**2).sqrt() * e_t
noise = sigma_t * noise_like(x.shape, device, repeat_noise) * temperature
if noise_dropout > 0.:
noise = torch.nn.functional.dropout(noise, p=noise_dropout)
x_prev = a_prev.sqrt() * pred_x0 + dir_xt + noise
return x_prev, pred_x0
| EXA-1-master | exa/libraries/latent-diffusion/ldm/models/diffusion/ddim.py |
import os
import torch
import pytorch_lightning as pl
from omegaconf import OmegaConf
from torch.nn import functional as F
from torch.optim import AdamW
from torch.optim.lr_scheduler import LambdaLR
from copy import deepcopy
from einops import rearrange
from glob import glob
from natsort import natsorted
from ldm.modules.diffusionmodules.openaimodel import EncoderUNetModel, UNetModel
from ldm.util import log_txt_as_img, default, ismap, instantiate_from_config
__models__ = {
'class_label': EncoderUNetModel,
'segmentation': UNetModel
}
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 NoisyLatentImageClassifier(pl.LightningModule):
def __init__(self,
diffusion_path,
num_classes,
ckpt_path=None,
pool='attention',
label_key=None,
diffusion_ckpt_path=None,
scheduler_config=None,
weight_decay=1.e-2,
log_steps=10,
monitor='val/loss',
*args,
**kwargs):
super().__init__(*args, **kwargs)
self.num_classes = num_classes
# get latest config of diffusion model
diffusion_config = natsorted(glob(os.path.join(diffusion_path, 'configs', '*-project.yaml')))[-1]
self.diffusion_config = OmegaConf.load(diffusion_config).model
self.diffusion_config.params.ckpt_path = diffusion_ckpt_path
self.load_diffusion()
self.monitor = monitor
self.numd = self.diffusion_model.first_stage_model.encoder.num_resolutions - 1
self.log_time_interval = self.diffusion_model.num_timesteps // log_steps
self.log_steps = log_steps
self.label_key = label_key if not hasattr(self.diffusion_model, 'cond_stage_key') \
else self.diffusion_model.cond_stage_key
assert self.label_key is not None, 'label_key neither in diffusion model nor in model.params'
if self.label_key not in __models__:
raise NotImplementedError()
self.load_classifier(ckpt_path, pool)
self.scheduler_config = scheduler_config
self.use_scheduler = self.scheduler_config is not None
self.weight_decay = weight_decay
def init_from_ckpt(self, path, ignore_keys=list(), only_model=False):
sd = torch.load(path, map_location="cpu")
if "state_dict" in list(sd.keys()):
sd = sd["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]
missing, unexpected = self.load_state_dict(sd, strict=False) if not only_model else self.model.load_state_dict(
sd, strict=False)
print(f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys")
if len(missing) > 0:
print(f"Missing Keys: {missing}")
if len(unexpected) > 0:
print(f"Unexpected Keys: {unexpected}")
def load_diffusion(self):
model = instantiate_from_config(self.diffusion_config)
self.diffusion_model = model.eval()
self.diffusion_model.train = disabled_train
for param in self.diffusion_model.parameters():
param.requires_grad = False
def load_classifier(self, ckpt_path, pool):
model_config = deepcopy(self.diffusion_config.params.unet_config.params)
model_config.in_channels = self.diffusion_config.params.unet_config.params.out_channels
model_config.out_channels = self.num_classes
if self.label_key == 'class_label':
model_config.pool = pool
self.model = __models__[self.label_key](**model_config)
if ckpt_path is not None:
print('#####################################################################')
print(f'load from ckpt "{ckpt_path}"')
print('#####################################################################')
self.init_from_ckpt(ckpt_path)
@torch.no_grad()
def get_x_noisy(self, x, t, noise=None):
noise = default(noise, lambda: torch.randn_like(x))
continuous_sqrt_alpha_cumprod = None
if self.diffusion_model.use_continuous_noise:
continuous_sqrt_alpha_cumprod = self.diffusion_model.sample_continuous_noise_level(x.shape[0], t + 1)
# todo: make sure t+1 is correct here
return self.diffusion_model.q_sample(x_start=x, t=t, noise=noise,
continuous_sqrt_alpha_cumprod=continuous_sqrt_alpha_cumprod)
def forward(self, x_noisy, t, *args, **kwargs):
return self.model(x_noisy, t)
@torch.no_grad()
def get_input(self, batch, k):
x = batch[k]
if len(x.shape) == 3:
x = x[..., None]
x = rearrange(x, 'b h w c -> b c h w')
x = x.to(memory_format=torch.contiguous_format).float()
return x
@torch.no_grad()
def get_conditioning(self, batch, k=None):
if k is None:
k = self.label_key
assert k is not None, 'Needs to provide label key'
targets = batch[k].to(self.device)
if self.label_key == 'segmentation':
targets = rearrange(targets, 'b h w c -> b c h w')
for down in range(self.numd):
h, w = targets.shape[-2:]
targets = F.interpolate(targets, size=(h // 2, w // 2), mode='nearest')
# targets = rearrange(targets,'b c h w -> b h w c')
return targets
def compute_top_k(self, logits, labels, k, reduction="mean"):
_, top_ks = torch.topk(logits, k, dim=1)
if reduction == "mean":
return (top_ks == labels[:, None]).float().sum(dim=-1).mean().item()
elif reduction == "none":
return (top_ks == labels[:, None]).float().sum(dim=-1)
def on_train_epoch_start(self):
# save some memory
self.diffusion_model.model.to('cpu')
@torch.no_grad()
def write_logs(self, loss, logits, targets):
log_prefix = 'train' if self.training else 'val'
log = {}
log[f"{log_prefix}/loss"] = loss.mean()
log[f"{log_prefix}/acc@1"] = self.compute_top_k(
logits, targets, k=1, reduction="mean"
)
log[f"{log_prefix}/acc@5"] = self.compute_top_k(
logits, targets, k=5, reduction="mean"
)
self.log_dict(log, prog_bar=False, logger=True, on_step=self.training, on_epoch=True)
self.log('loss', log[f"{log_prefix}/loss"], prog_bar=True, logger=False)
self.log('global_step', self.global_step, logger=False, on_epoch=False, prog_bar=True)
lr = self.optimizers().param_groups[0]['lr']
self.log('lr_abs', lr, on_step=True, logger=True, on_epoch=False, prog_bar=True)
def shared_step(self, batch, t=None):
x, *_ = self.diffusion_model.get_input(batch, k=self.diffusion_model.first_stage_key)
targets = self.get_conditioning(batch)
if targets.dim() == 4:
targets = targets.argmax(dim=1)
if t is None:
t = torch.randint(0, self.diffusion_model.num_timesteps, (x.shape[0],), device=self.device).long()
else:
t = torch.full(size=(x.shape[0],), fill_value=t, device=self.device).long()
x_noisy = self.get_x_noisy(x, t)
logits = self(x_noisy, t)
loss = F.cross_entropy(logits, targets, reduction='none')
self.write_logs(loss.detach(), logits.detach(), targets.detach())
loss = loss.mean()
return loss, logits, x_noisy, targets
def training_step(self, batch, batch_idx):
loss, *_ = self.shared_step(batch)
return loss
def reset_noise_accs(self):
self.noisy_acc = {t: {'acc@1': [], 'acc@5': []} for t in
range(0, self.diffusion_model.num_timesteps, self.diffusion_model.log_every_t)}
def on_validation_start(self):
self.reset_noise_accs()
@torch.no_grad()
def validation_step(self, batch, batch_idx):
loss, *_ = self.shared_step(batch)
for t in self.noisy_acc:
_, logits, _, targets = self.shared_step(batch, t)
self.noisy_acc[t]['acc@1'].append(self.compute_top_k(logits, targets, k=1, reduction='mean'))
self.noisy_acc[t]['acc@5'].append(self.compute_top_k(logits, targets, k=5, reduction='mean'))
return loss
def configure_optimizers(self):
optimizer = AdamW(self.model.parameters(), lr=self.learning_rate, weight_decay=self.weight_decay)
if self.use_scheduler:
scheduler = instantiate_from_config(self.scheduler_config)
print("Setting up LambdaLR scheduler...")
scheduler = [
{
'scheduler': LambdaLR(optimizer, lr_lambda=scheduler.schedule),
'interval': 'step',
'frequency': 1
}]
return [optimizer], scheduler
return optimizer
@torch.no_grad()
def log_images(self, batch, N=8, *args, **kwargs):
log = dict()
x = self.get_input(batch, self.diffusion_model.first_stage_key)
log['inputs'] = x
y = self.get_conditioning(batch)
if self.label_key == 'class_label':
y = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"])
log['labels'] = y
if ismap(y):
log['labels'] = self.diffusion_model.to_rgb(y)
for step in range(self.log_steps):
current_time = step * self.log_time_interval
_, logits, x_noisy, _ = self.shared_step(batch, t=current_time)
log[f'inputs@t{current_time}'] = x_noisy
pred = F.one_hot(logits.argmax(dim=1), num_classes=self.num_classes)
pred = rearrange(pred, 'b h w c -> b c h w')
log[f'pred@t{current_time}'] = self.diffusion_model.to_rgb(pred)
for key in log:
log[key] = log[key][:N]
return log
| EXA-1-master | exa/libraries/latent-diffusion/ldm/models/diffusion/classifier.py |
EXA-1-master | exa/libraries/latent-diffusion/ldm/models/diffusion/__init__.py |
|
"""SAMPLING ONLY."""
import torch
import numpy as np
from tqdm import tqdm
from functools import partial
from ldm.modules.diffusionmodules.util import make_ddim_sampling_parameters, make_ddim_timesteps, noise_like
class PLMSSampler(object):
def __init__(self, model, schedule="linear", **kwargs):
super().__init__()
self.model = model
self.ddpm_num_timesteps = model.num_timesteps
self.schedule = schedule
def register_buffer(self, name, attr):
if type(attr) == torch.Tensor:
if attr.device != torch.device("cuda"):
attr = attr.to(torch.device("cuda"))
setattr(self, name, attr)
def make_schedule(self, ddim_num_steps, ddim_discretize="uniform", ddim_eta=0., verbose=True):
if ddim_eta != 0:
raise ValueError('ddim_eta must be 0 for PLMS')
self.ddim_timesteps = make_ddim_timesteps(ddim_discr_method=ddim_discretize, num_ddim_timesteps=ddim_num_steps,
num_ddpm_timesteps=self.ddpm_num_timesteps,verbose=verbose)
alphas_cumprod = self.model.alphas_cumprod
assert alphas_cumprod.shape[0] == self.ddpm_num_timesteps, 'alphas have to be defined for each timestep'
to_torch = lambda x: x.clone().detach().to(torch.float32).to(self.model.device)
self.register_buffer('betas', to_torch(self.model.betas))
self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod))
self.register_buffer('alphas_cumprod_prev', to_torch(self.model.alphas_cumprod_prev))
# calculations for diffusion q(x_t | x_{t-1}) and others
self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod.cpu())))
self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod.cpu())))
self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod.cpu())))
self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu())))
self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod.cpu() - 1)))
# ddim sampling parameters
ddim_sigmas, ddim_alphas, ddim_alphas_prev = make_ddim_sampling_parameters(alphacums=alphas_cumprod.cpu(),
ddim_timesteps=self.ddim_timesteps,
eta=ddim_eta,verbose=verbose)
self.register_buffer('ddim_sigmas', ddim_sigmas)
self.register_buffer('ddim_alphas', ddim_alphas)
self.register_buffer('ddim_alphas_prev', ddim_alphas_prev)
self.register_buffer('ddim_sqrt_one_minus_alphas', np.sqrt(1. - ddim_alphas))
sigmas_for_original_sampling_steps = ddim_eta * torch.sqrt(
(1 - self.alphas_cumprod_prev) / (1 - self.alphas_cumprod) * (
1 - self.alphas_cumprod / self.alphas_cumprod_prev))
self.register_buffer('ddim_sigmas_for_original_num_steps', sigmas_for_original_sampling_steps)
@torch.no_grad()
def sample(self,
S,
batch_size,
shape,
conditioning=None,
callback=None,
normals_sequence=None,
img_callback=None,
quantize_x0=False,
eta=0.,
mask=None,
x0=None,
temperature=1.,
noise_dropout=0.,
score_corrector=None,
corrector_kwargs=None,
verbose=True,
x_T=None,
log_every_t=100,
unconditional_guidance_scale=1.,
unconditional_conditioning=None,
# this has to come in the same format as the conditioning, # e.g. as encoded tokens, ...
**kwargs
):
if conditioning is not None:
if isinstance(conditioning, dict):
cbs = conditioning[list(conditioning.keys())[0]].shape[0]
if cbs != batch_size:
print(f"Warning: Got {cbs} conditionings but batch-size is {batch_size}")
else:
if conditioning.shape[0] != batch_size:
print(f"Warning: Got {conditioning.shape[0]} conditionings but batch-size is {batch_size}")
self.make_schedule(ddim_num_steps=S, ddim_eta=eta, verbose=verbose)
# sampling
C, H, W = shape
size = (batch_size, C, H, W)
print(f'Data shape for PLMS sampling is {size}')
samples, intermediates = self.plms_sampling(conditioning, size,
callback=callback,
img_callback=img_callback,
quantize_denoised=quantize_x0,
mask=mask, x0=x0,
ddim_use_original_steps=False,
noise_dropout=noise_dropout,
temperature=temperature,
score_corrector=score_corrector,
corrector_kwargs=corrector_kwargs,
x_T=x_T,
log_every_t=log_every_t,
unconditional_guidance_scale=unconditional_guidance_scale,
unconditional_conditioning=unconditional_conditioning,
)
return samples, intermediates
@torch.no_grad()
def plms_sampling(self, cond, shape,
x_T=None, ddim_use_original_steps=False,
callback=None, timesteps=None, quantize_denoised=False,
mask=None, x0=None, img_callback=None, log_every_t=100,
temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,
unconditional_guidance_scale=1., unconditional_conditioning=None,):
device = self.model.betas.device
b = shape[0]
if x_T is None:
img = torch.randn(shape, device=device)
else:
img = x_T
if timesteps is None:
timesteps = self.ddpm_num_timesteps if ddim_use_original_steps else self.ddim_timesteps
elif timesteps is not None and not ddim_use_original_steps:
subset_end = int(min(timesteps / self.ddim_timesteps.shape[0], 1) * self.ddim_timesteps.shape[0]) - 1
timesteps = self.ddim_timesteps[:subset_end]
intermediates = {'x_inter': [img], 'pred_x0': [img]}
time_range = list(reversed(range(0,timesteps))) if ddim_use_original_steps else np.flip(timesteps)
total_steps = timesteps if ddim_use_original_steps else timesteps.shape[0]
print(f"Running PLMS Sampling with {total_steps} timesteps")
iterator = tqdm(time_range, desc='PLMS Sampler', total=total_steps)
old_eps = []
for i, step in enumerate(iterator):
index = total_steps - i - 1
ts = torch.full((b,), step, device=device, dtype=torch.long)
ts_next = torch.full((b,), time_range[min(i + 1, len(time_range) - 1)], device=device, dtype=torch.long)
if mask is not None:
assert x0 is not None
img_orig = self.model.q_sample(x0, ts) # TODO: deterministic forward pass?
img = img_orig * mask + (1. - mask) * img
outs = self.p_sample_plms(img, cond, ts, index=index, use_original_steps=ddim_use_original_steps,
quantize_denoised=quantize_denoised, temperature=temperature,
noise_dropout=noise_dropout, score_corrector=score_corrector,
corrector_kwargs=corrector_kwargs,
unconditional_guidance_scale=unconditional_guidance_scale,
unconditional_conditioning=unconditional_conditioning,
old_eps=old_eps, t_next=ts_next)
img, pred_x0, e_t = outs
old_eps.append(e_t)
if len(old_eps) >= 4:
old_eps.pop(0)
if callback: callback(i)
if img_callback: img_callback(pred_x0, i)
if index % log_every_t == 0 or index == total_steps - 1:
intermediates['x_inter'].append(img)
intermediates['pred_x0'].append(pred_x0)
return img, intermediates
@torch.no_grad()
def p_sample_plms(self, x, c, t, index, repeat_noise=False, use_original_steps=False, quantize_denoised=False,
temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None,
unconditional_guidance_scale=1., unconditional_conditioning=None, old_eps=None, t_next=None):
b, *_, device = *x.shape, x.device
def get_model_output(x, t):
if unconditional_conditioning is None or unconditional_guidance_scale == 1.:
e_t = self.model.apply_model(x, t, c)
else:
x_in = torch.cat([x] * 2)
t_in = torch.cat([t] * 2)
c_in = torch.cat([unconditional_conditioning, c])
e_t_uncond, e_t = self.model.apply_model(x_in, t_in, c_in).chunk(2)
e_t = e_t_uncond + unconditional_guidance_scale * (e_t - e_t_uncond)
if score_corrector is not None:
assert self.model.parameterization == "eps"
e_t = score_corrector.modify_score(self.model, e_t, x, t, c, **corrector_kwargs)
return e_t
alphas = self.model.alphas_cumprod if use_original_steps else self.ddim_alphas
alphas_prev = self.model.alphas_cumprod_prev if use_original_steps else self.ddim_alphas_prev
sqrt_one_minus_alphas = self.model.sqrt_one_minus_alphas_cumprod if use_original_steps else self.ddim_sqrt_one_minus_alphas
sigmas = self.model.ddim_sigmas_for_original_num_steps if use_original_steps else self.ddim_sigmas
def get_x_prev_and_pred_x0(e_t, index):
# select parameters corresponding to the currently considered timestep
a_t = torch.full((b, 1, 1, 1), alphas[index], device=device)
a_prev = torch.full((b, 1, 1, 1), alphas_prev[index], device=device)
sigma_t = torch.full((b, 1, 1, 1), sigmas[index], device=device)
sqrt_one_minus_at = torch.full((b, 1, 1, 1), sqrt_one_minus_alphas[index],device=device)
# current prediction for x_0
pred_x0 = (x - sqrt_one_minus_at * e_t) / a_t.sqrt()
if quantize_denoised:
pred_x0, _, *_ = self.model.first_stage_model.quantize(pred_x0)
# direction pointing to x_t
dir_xt = (1. - a_prev - sigma_t**2).sqrt() * e_t
noise = sigma_t * noise_like(x.shape, device, repeat_noise) * temperature
if noise_dropout > 0.:
noise = torch.nn.functional.dropout(noise, p=noise_dropout)
x_prev = a_prev.sqrt() * pred_x0 + dir_xt + noise
return x_prev, pred_x0
e_t = get_model_output(x, t)
if len(old_eps) == 0:
# Pseudo Improved Euler (2nd order)
x_prev, pred_x0 = get_x_prev_and_pred_x0(e_t, index)
e_t_next = get_model_output(x_prev, t_next)
e_t_prime = (e_t + e_t_next) / 2
elif len(old_eps) == 1:
# 2nd order Pseudo Linear Multistep (Adams-Bashforth)
e_t_prime = (3 * e_t - old_eps[-1]) / 2
elif len(old_eps) == 2:
# 3nd order Pseudo Linear Multistep (Adams-Bashforth)
e_t_prime = (23 * e_t - 16 * old_eps[-1] + 5 * old_eps[-2]) / 12
elif len(old_eps) >= 3:
# 4nd order Pseudo Linear Multistep (Adams-Bashforth)
e_t_prime = (55 * e_t - 59 * old_eps[-1] + 37 * old_eps[-2] - 9 * old_eps[-3]) / 24
x_prev, pred_x0 = get_x_prev_and_pred_x0(e_t_prime, index)
return x_prev, pred_x0, e_t
| EXA-1-master | exa/libraries/latent-diffusion/ldm/models/diffusion/plms.py |
"""
wild mixture of
https://github.com/lucidrains/denoising-diffusion-pytorch/blob/7706bdfc6f527f58d33f84b7b522e61e6e3164b3/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py
https://github.com/openai/improved-diffusion/blob/e94489283bb876ac1477d5dd7709bbbd2d9902ce/improved_diffusion/gaussian_diffusion.py
https://github.com/CompVis/taming-transformers
-- merci
"""
import torch
import torch.nn as nn
import numpy as np
import pytorch_lightning as pl
from torch.optim.lr_scheduler import LambdaLR
from einops import rearrange, repeat
from contextlib import contextmanager
from functools import partial
from tqdm import tqdm
from torchvision.utils import make_grid
from pytorch_lightning.utilities.distributed import rank_zero_only
from ldm.util import log_txt_as_img, exists, default, ismap, isimage, mean_flat, count_params, instantiate_from_config
from ldm.modules.ema import LitEma
from ldm.modules.distributions.distributions import normal_kl, DiagonalGaussianDistribution
from ldm.models.autoencoder import VQModelInterface, IdentityFirstStage, AutoencoderKL
from ldm.modules.diffusionmodules.util import make_beta_schedule, extract_into_tensor, noise_like
from ldm.models.diffusion.ddim import DDIMSampler
__conditioning_keys__ = {'concat': 'c_concat',
'crossattn': 'c_crossattn',
'adm': 'y'}
def disabled_train(self, mode=True):
"""Overwrite model.train with this function to make sure train/eval mode
does not change anymore."""
return self
def uniform_on_device(r1, r2, shape, device):
return (r1 - r2) * torch.rand(*shape, device=device) + r2
class DDPM(pl.LightningModule):
# classic DDPM with Gaussian diffusion, in image space
def __init__(self,
unet_config,
timesteps=1000,
beta_schedule="linear",
loss_type="l2",
ckpt_path=None,
ignore_keys=[],
load_only_unet=False,
monitor="val/loss",
use_ema=True,
first_stage_key="image",
image_size=256,
channels=3,
log_every_t=100,
clip_denoised=True,
linear_start=1e-4,
linear_end=2e-2,
cosine_s=8e-3,
given_betas=None,
original_elbo_weight=0.,
v_posterior=0., # weight for choosing posterior variance as sigma = (1-v) * beta_tilde + v * beta
l_simple_weight=1.,
conditioning_key=None,
parameterization="eps", # all assuming fixed variance schedules
scheduler_config=None,
use_positional_encodings=False,
learn_logvar=False,
logvar_init=0.,
):
super().__init__()
assert parameterization in ["eps", "x0"], 'currently only supporting "eps" and "x0"'
self.parameterization = parameterization
print(f"{self.__class__.__name__}: Running in {self.parameterization}-prediction mode")
self.cond_stage_model = None
self.clip_denoised = clip_denoised
self.log_every_t = log_every_t
self.first_stage_key = first_stage_key
self.image_size = image_size # try conv?
self.channels = channels
self.use_positional_encodings = use_positional_encodings
self.model = DiffusionWrapper(unet_config, conditioning_key)
count_params(self.model, verbose=True)
self.use_ema = use_ema
if self.use_ema:
self.model_ema = LitEma(self.model)
print(f"Keeping EMAs of {len(list(self.model_ema.buffers()))}.")
self.use_scheduler = scheduler_config is not None
if self.use_scheduler:
self.scheduler_config = scheduler_config
self.v_posterior = v_posterior
self.original_elbo_weight = original_elbo_weight
self.l_simple_weight = l_simple_weight
if monitor is not None:
self.monitor = monitor
if ckpt_path is not None:
self.init_from_ckpt(ckpt_path, ignore_keys=ignore_keys, only_model=load_only_unet)
self.register_schedule(given_betas=given_betas, beta_schedule=beta_schedule, timesteps=timesteps,
linear_start=linear_start, linear_end=linear_end, cosine_s=cosine_s)
self.loss_type = loss_type
self.learn_logvar = learn_logvar
self.logvar = torch.full(fill_value=logvar_init, size=(self.num_timesteps,))
if self.learn_logvar:
self.logvar = nn.Parameter(self.logvar, requires_grad=True)
def register_schedule(self, given_betas=None, beta_schedule="linear", timesteps=1000,
linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):
if exists(given_betas):
betas = given_betas
else:
betas = make_beta_schedule(beta_schedule, timesteps, linear_start=linear_start, linear_end=linear_end,
cosine_s=cosine_s)
alphas = 1. - betas
alphas_cumprod = np.cumprod(alphas, axis=0)
alphas_cumprod_prev = np.append(1., alphas_cumprod[:-1])
timesteps, = betas.shape
self.num_timesteps = int(timesteps)
self.linear_start = linear_start
self.linear_end = linear_end
assert alphas_cumprod.shape[0] == self.num_timesteps, 'alphas have to be defined for each timestep'
to_torch = partial(torch.tensor, dtype=torch.float32)
self.register_buffer('betas', to_torch(betas))
self.register_buffer('alphas_cumprod', to_torch(alphas_cumprod))
self.register_buffer('alphas_cumprod_prev', to_torch(alphas_cumprod_prev))
# calculations for diffusion q(x_t | x_{t-1}) and others
self.register_buffer('sqrt_alphas_cumprod', to_torch(np.sqrt(alphas_cumprod)))
self.register_buffer('sqrt_one_minus_alphas_cumprod', to_torch(np.sqrt(1. - alphas_cumprod)))
self.register_buffer('log_one_minus_alphas_cumprod', to_torch(np.log(1. - alphas_cumprod)))
self.register_buffer('sqrt_recip_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod)))
self.register_buffer('sqrt_recipm1_alphas_cumprod', to_torch(np.sqrt(1. / alphas_cumprod - 1)))
# calculations for posterior q(x_{t-1} | x_t, x_0)
posterior_variance = (1 - self.v_posterior) * betas * (1. - alphas_cumprod_prev) / (
1. - alphas_cumprod) + self.v_posterior * betas
# above: equal to 1. / (1. / (1. - alpha_cumprod_tm1) + alpha_t / beta_t)
self.register_buffer('posterior_variance', to_torch(posterior_variance))
# below: log calculation clipped because the posterior variance is 0 at the beginning of the diffusion chain
self.register_buffer('posterior_log_variance_clipped', to_torch(np.log(np.maximum(posterior_variance, 1e-20))))
self.register_buffer('posterior_mean_coef1', to_torch(
betas * np.sqrt(alphas_cumprod_prev) / (1. - alphas_cumprod)))
self.register_buffer('posterior_mean_coef2', to_torch(
(1. - alphas_cumprod_prev) * np.sqrt(alphas) / (1. - alphas_cumprod)))
if self.parameterization == "eps":
lvlb_weights = self.betas ** 2 / (
2 * self.posterior_variance * to_torch(alphas) * (1 - self.alphas_cumprod))
elif self.parameterization == "x0":
lvlb_weights = 0.5 * np.sqrt(torch.Tensor(alphas_cumprod)) / (2. * 1 - torch.Tensor(alphas_cumprod))
else:
raise NotImplementedError("mu not supported")
# TODO how to choose this term
lvlb_weights[0] = lvlb_weights[1]
self.register_buffer('lvlb_weights', lvlb_weights, persistent=False)
assert not torch.isnan(self.lvlb_weights).all()
@contextmanager
def ema_scope(self, context=None):
if self.use_ema:
self.model_ema.store(self.model.parameters())
self.model_ema.copy_to(self.model)
if context is not None:
print(f"{context}: Switched to EMA weights")
try:
yield None
finally:
if self.use_ema:
self.model_ema.restore(self.model.parameters())
if context is not None:
print(f"{context}: Restored training weights")
def init_from_ckpt(self, path, ignore_keys=list(), only_model=False):
sd = torch.load(path, map_location="cpu")
if "state_dict" in list(sd.keys()):
sd = sd["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]
missing, unexpected = self.load_state_dict(sd, strict=False) if not only_model else self.model.load_state_dict(
sd, strict=False)
print(f"Restored from {path} with {len(missing)} missing and {len(unexpected)} unexpected keys")
if len(missing) > 0:
print(f"Missing Keys: {missing}")
if len(unexpected) > 0:
print(f"Unexpected Keys: {unexpected}")
def q_mean_variance(self, x_start, t):
"""
Get the distribution q(x_t | x_0).
:param x_start: the [N x C x ...] tensor of noiseless inputs.
:param t: the number of diffusion steps (minus 1). Here, 0 means one step.
:return: A tuple (mean, variance, log_variance), all of x_start's shape.
"""
mean = (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start)
variance = extract_into_tensor(1.0 - self.alphas_cumprod, t, x_start.shape)
log_variance = extract_into_tensor(self.log_one_minus_alphas_cumprod, t, x_start.shape)
return mean, variance, log_variance
def predict_start_from_noise(self, x_t, t, noise):
return (
extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t -
extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape) * noise
)
def q_posterior(self, x_start, x_t, t):
posterior_mean = (
extract_into_tensor(self.posterior_mean_coef1, t, x_t.shape) * x_start +
extract_into_tensor(self.posterior_mean_coef2, t, x_t.shape) * x_t
)
posterior_variance = extract_into_tensor(self.posterior_variance, t, x_t.shape)
posterior_log_variance_clipped = extract_into_tensor(self.posterior_log_variance_clipped, t, x_t.shape)
return posterior_mean, posterior_variance, posterior_log_variance_clipped
def p_mean_variance(self, x, t, clip_denoised: bool):
model_out = self.model(x, t)
if self.parameterization == "eps":
x_recon = self.predict_start_from_noise(x, t=t, noise=model_out)
elif self.parameterization == "x0":
x_recon = model_out
if clip_denoised:
x_recon.clamp_(-1., 1.)
model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t)
return model_mean, posterior_variance, posterior_log_variance
@torch.no_grad()
def p_sample(self, x, t, clip_denoised=True, repeat_noise=False):
b, *_, device = *x.shape, x.device
model_mean, _, model_log_variance = self.p_mean_variance(x=x, t=t, clip_denoised=clip_denoised)
noise = noise_like(x.shape, device, repeat_noise)
# no noise when t == 0
nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))
return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise
@torch.no_grad()
def p_sample_loop(self, shape, return_intermediates=False):
device = self.betas.device
b = shape[0]
img = torch.randn(shape, device=device)
intermediates = [img]
for i in tqdm(reversed(range(0, self.num_timesteps)), desc='Sampling t', total=self.num_timesteps):
img = self.p_sample(img, torch.full((b,), i, device=device, dtype=torch.long),
clip_denoised=self.clip_denoised)
if i % self.log_every_t == 0 or i == self.num_timesteps - 1:
intermediates.append(img)
if return_intermediates:
return img, intermediates
return img
@torch.no_grad()
def sample(self, batch_size=16, return_intermediates=False):
image_size = self.image_size
channels = self.channels
return self.p_sample_loop((batch_size, channels, image_size, image_size),
return_intermediates=return_intermediates)
def q_sample(self, x_start, t, noise=None):
noise = default(noise, lambda: torch.randn_like(x_start))
return (extract_into_tensor(self.sqrt_alphas_cumprod, t, x_start.shape) * x_start +
extract_into_tensor(self.sqrt_one_minus_alphas_cumprod, t, x_start.shape) * noise)
def get_loss(self, pred, target, mean=True):
if self.loss_type == 'l1':
loss = (target - pred).abs()
if mean:
loss = loss.mean()
elif self.loss_type == 'l2':
if mean:
loss = torch.nn.functional.mse_loss(target, pred)
else:
loss = torch.nn.functional.mse_loss(target, pred, reduction='none')
else:
raise NotImplementedError("unknown loss type '{loss_type}'")
return loss
def p_losses(self, x_start, t, noise=None):
noise = default(noise, lambda: torch.randn_like(x_start))
x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
model_out = self.model(x_noisy, t)
loss_dict = {}
if self.parameterization == "eps":
target = noise
elif self.parameterization == "x0":
target = x_start
else:
raise NotImplementedError(f"Paramterization {self.parameterization} not yet supported")
loss = self.get_loss(model_out, target, mean=False).mean(dim=[1, 2, 3])
log_prefix = 'train' if self.training else 'val'
loss_dict.update({f'{log_prefix}/loss_simple': loss.mean()})
loss_simple = loss.mean() * self.l_simple_weight
loss_vlb = (self.lvlb_weights[t] * loss).mean()
loss_dict.update({f'{log_prefix}/loss_vlb': loss_vlb})
loss = loss_simple + self.original_elbo_weight * loss_vlb
loss_dict.update({f'{log_prefix}/loss': loss})
return loss, loss_dict
def forward(self, x, *args, **kwargs):
# b, c, h, w, device, img_size, = *x.shape, x.device, self.image_size
# assert h == img_size and w == img_size, f'height and width of image must be {img_size}'
t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long()
return self.p_losses(x, t, *args, **kwargs)
def get_input(self, batch, k):
x = batch[k]
if len(x.shape) == 3:
x = x[..., None]
x = rearrange(x, 'b h w c -> b c h w')
x = x.to(memory_format=torch.contiguous_format).float()
return x
def shared_step(self, batch):
x = self.get_input(batch, self.first_stage_key)
loss, loss_dict = self(x)
return loss, loss_dict
def training_step(self, batch, batch_idx):
loss, loss_dict = self.shared_step(batch)
self.log_dict(loss_dict, prog_bar=True,
logger=True, on_step=True, on_epoch=True)
self.log("global_step", self.global_step,
prog_bar=True, logger=True, on_step=True, on_epoch=False)
if self.use_scheduler:
lr = self.optimizers().param_groups[0]['lr']
self.log('lr_abs', lr, prog_bar=True, logger=True, on_step=True, on_epoch=False)
return loss
@torch.no_grad()
def validation_step(self, batch, batch_idx):
_, loss_dict_no_ema = self.shared_step(batch)
with self.ema_scope():
_, loss_dict_ema = self.shared_step(batch)
loss_dict_ema = {key + '_ema': loss_dict_ema[key] for key in loss_dict_ema}
self.log_dict(loss_dict_no_ema, prog_bar=False, logger=True, on_step=False, on_epoch=True)
self.log_dict(loss_dict_ema, prog_bar=False, logger=True, on_step=False, on_epoch=True)
def on_train_batch_end(self, *args, **kwargs):
if self.use_ema:
self.model_ema(self.model)
def _get_rows_from_list(self, samples):
n_imgs_per_row = len(samples)
denoise_grid = rearrange(samples, 'n b c h w -> b n c h w')
denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w')
denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row)
return denoise_grid
@torch.no_grad()
def log_images(self, batch, N=8, n_row=2, sample=True, return_keys=None, **kwargs):
log = dict()
x = self.get_input(batch, self.first_stage_key)
N = min(x.shape[0], N)
n_row = min(x.shape[0], n_row)
x = x.to(self.device)[:N]
log["inputs"] = x
# get diffusion row
diffusion_row = list()
x_start = x[:n_row]
for t in range(self.num_timesteps):
if t % self.log_every_t == 0 or t == self.num_timesteps - 1:
t = repeat(torch.tensor([t]), '1 -> b', b=n_row)
t = t.to(self.device).long()
noise = torch.randn_like(x_start)
x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
diffusion_row.append(x_noisy)
log["diffusion_row"] = self._get_rows_from_list(diffusion_row)
if sample:
# get denoise row
with self.ema_scope("Plotting"):
samples, denoise_row = self.sample(batch_size=N, return_intermediates=True)
log["samples"] = samples
log["denoise_row"] = self._get_rows_from_list(denoise_row)
if return_keys:
if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0:
return log
else:
return {key: log[key] for key in return_keys}
return log
def configure_optimizers(self):
lr = self.learning_rate
params = list(self.model.parameters())
if self.learn_logvar:
params = params + [self.logvar]
opt = torch.optim.AdamW(params, lr=lr)
return opt
class LatentDiffusion(DDPM):
"""main class"""
def __init__(self,
first_stage_config,
cond_stage_config,
num_timesteps_cond=None,
cond_stage_key="image",
cond_stage_trainable=False,
concat_mode=True,
cond_stage_forward=None,
conditioning_key=None,
scale_factor=1.0,
scale_by_std=False,
*args, **kwargs):
self.num_timesteps_cond = default(num_timesteps_cond, 1)
self.scale_by_std = scale_by_std
assert self.num_timesteps_cond <= kwargs['timesteps']
# for backwards compatibility after implementation of DiffusionWrapper
if conditioning_key is None:
conditioning_key = 'concat' if concat_mode else 'crossattn'
if cond_stage_config == '__is_unconditional__':
conditioning_key = None
ckpt_path = kwargs.pop("ckpt_path", None)
ignore_keys = kwargs.pop("ignore_keys", [])
super().__init__(conditioning_key=conditioning_key, *args, **kwargs)
self.concat_mode = concat_mode
self.cond_stage_trainable = cond_stage_trainable
self.cond_stage_key = cond_stage_key
try:
self.num_downs = len(first_stage_config.params.ddconfig.ch_mult) - 1
except:
self.num_downs = 0
if not scale_by_std:
self.scale_factor = scale_factor
else:
self.register_buffer('scale_factor', torch.tensor(scale_factor))
self.instantiate_first_stage(first_stage_config)
self.instantiate_cond_stage(cond_stage_config)
self.cond_stage_forward = cond_stage_forward
self.clip_denoised = False
self.bbox_tokenizer = None
self.restarted_from_ckpt = False
if ckpt_path is not None:
self.init_from_ckpt(ckpt_path, ignore_keys)
self.restarted_from_ckpt = True
def make_cond_schedule(self, ):
self.cond_ids = torch.full(size=(self.num_timesteps,), fill_value=self.num_timesteps - 1, dtype=torch.long)
ids = torch.round(torch.linspace(0, self.num_timesteps - 1, self.num_timesteps_cond)).long()
self.cond_ids[:self.num_timesteps_cond] = ids
@rank_zero_only
@torch.no_grad()
def on_train_batch_start(self, batch, batch_idx, dataloader_idx):
# only for very first batch
if self.scale_by_std and self.current_epoch == 0 and self.global_step == 0 and batch_idx == 0 and not self.restarted_from_ckpt:
assert self.scale_factor == 1., 'rather not use custom rescaling and std-rescaling simultaneously'
# set rescale weight to 1./std of encodings
print("### USING STD-RESCALING ###")
x = super().get_input(batch, self.first_stage_key)
x = x.to(self.device)
encoder_posterior = self.encode_first_stage(x)
z = self.get_first_stage_encoding(encoder_posterior).detach()
del self.scale_factor
self.register_buffer('scale_factor', 1. / z.flatten().std())
print(f"setting self.scale_factor to {self.scale_factor}")
print("### USING STD-RESCALING ###")
def register_schedule(self,
given_betas=None, beta_schedule="linear", timesteps=1000,
linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):
super().register_schedule(given_betas, beta_schedule, timesteps, linear_start, linear_end, cosine_s)
self.shorten_cond_schedule = self.num_timesteps_cond > 1
if self.shorten_cond_schedule:
self.make_cond_schedule()
def instantiate_first_stage(self, config):
model = instantiate_from_config(config)
self.first_stage_model = model.eval()
self.first_stage_model.train = disabled_train
for param in self.first_stage_model.parameters():
param.requires_grad = False
def instantiate_cond_stage(self, config):
if not self.cond_stage_trainable:
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__":
print(f"Training {self.__class__.__name__} as an unconditional model.")
self.cond_stage_model = None
# self.be_unconditional = True
else:
model = instantiate_from_config(config)
self.cond_stage_model = model.eval()
self.cond_stage_model.train = disabled_train
for param in self.cond_stage_model.parameters():
param.requires_grad = False
else:
assert config != '__is_first_stage__'
assert config != '__is_unconditional__'
model = instantiate_from_config(config)
self.cond_stage_model = model
def _get_denoise_row_from_list(self, samples, desc='', force_no_decoder_quantization=False):
denoise_row = []
for zd in tqdm(samples, desc=desc):
denoise_row.append(self.decode_first_stage(zd.to(self.device),
force_not_quantize=force_no_decoder_quantization))
n_imgs_per_row = len(denoise_row)
denoise_row = torch.stack(denoise_row) # n_log_step, n_row, C, H, W
denoise_grid = rearrange(denoise_row, 'n b c h w -> b n c h w')
denoise_grid = rearrange(denoise_grid, 'b n c h w -> (b n) c h w')
denoise_grid = make_grid(denoise_grid, nrow=n_imgs_per_row)
return denoise_grid
def get_first_stage_encoding(self, encoder_posterior):
if isinstance(encoder_posterior, DiagonalGaussianDistribution):
z = encoder_posterior.sample()
elif isinstance(encoder_posterior, torch.Tensor):
z = encoder_posterior
else:
raise NotImplementedError(f"encoder_posterior of type '{type(encoder_posterior)}' not yet implemented")
return self.scale_factor * z
def get_learned_conditioning(self, c):
if self.cond_stage_forward is None:
if hasattr(self.cond_stage_model, 'encode') and callable(self.cond_stage_model.encode):
c = self.cond_stage_model.encode(c)
if isinstance(c, DiagonalGaussianDistribution):
c = c.mode()
else:
c = self.cond_stage_model(c)
else:
assert hasattr(self.cond_stage_model, self.cond_stage_forward)
c = getattr(self.cond_stage_model, self.cond_stage_forward)(c)
return c
def meshgrid(self, h, w):
y = torch.arange(0, h).view(h, 1, 1).repeat(1, w, 1)
x = torch.arange(0, w).view(1, w, 1).repeat(h, 1, 1)
arr = torch.cat([y, x], dim=-1)
return arr
def delta_border(self, h, w):
"""
:param h: height
:param w: width
:return: normalized distance to image border,
wtith min distance = 0 at border and max dist = 0.5 at image center
"""
lower_right_corner = torch.tensor([h - 1, w - 1]).view(1, 1, 2)
arr = self.meshgrid(h, w) / lower_right_corner
dist_left_up = torch.min(arr, dim=-1, keepdims=True)[0]
dist_right_down = torch.min(1 - arr, dim=-1, keepdims=True)[0]
edge_dist = torch.min(torch.cat([dist_left_up, dist_right_down], dim=-1), dim=-1)[0]
return edge_dist
def get_weighting(self, h, w, Ly, Lx, device):
weighting = self.delta_border(h, w)
weighting = torch.clip(weighting, self.split_input_params["clip_min_weight"],
self.split_input_params["clip_max_weight"], )
weighting = weighting.view(1, h * w, 1).repeat(1, 1, Ly * Lx).to(device)
if self.split_input_params["tie_braker"]:
L_weighting = self.delta_border(Ly, Lx)
L_weighting = torch.clip(L_weighting,
self.split_input_params["clip_min_tie_weight"],
self.split_input_params["clip_max_tie_weight"])
L_weighting = L_weighting.view(1, 1, Ly * Lx).to(device)
weighting = weighting * L_weighting
return weighting
def get_fold_unfold(self, x, kernel_size, stride, uf=1, df=1): # todo load once not every time, shorten code
"""
:param x: img of size (bs, c, h, w)
:return: n img crops of size (n, bs, c, kernel_size[0], kernel_size[1])
"""
bs, nc, h, w = x.shape
# number of crops in image
Ly = (h - kernel_size[0]) // stride[0] + 1
Lx = (w - kernel_size[1]) // stride[1] + 1
if uf == 1 and df == 1:
fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)
unfold = torch.nn.Unfold(**fold_params)
fold = torch.nn.Fold(output_size=x.shape[2:], **fold_params)
weighting = self.get_weighting(kernel_size[0], kernel_size[1], Ly, Lx, x.device).to(x.dtype)
normalization = fold(weighting).view(1, 1, h, w) # normalizes the overlap
weighting = weighting.view((1, 1, kernel_size[0], kernel_size[1], Ly * Lx))
elif uf > 1 and df == 1:
fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)
unfold = torch.nn.Unfold(**fold_params)
fold_params2 = dict(kernel_size=(kernel_size[0] * uf, kernel_size[0] * uf),
dilation=1, padding=0,
stride=(stride[0] * uf, stride[1] * uf))
fold = torch.nn.Fold(output_size=(x.shape[2] * uf, x.shape[3] * uf), **fold_params2)
weighting = self.get_weighting(kernel_size[0] * uf, kernel_size[1] * uf, Ly, Lx, x.device).to(x.dtype)
normalization = fold(weighting).view(1, 1, h * uf, w * uf) # normalizes the overlap
weighting = weighting.view((1, 1, kernel_size[0] * uf, kernel_size[1] * uf, Ly * Lx))
elif df > 1 and uf == 1:
fold_params = dict(kernel_size=kernel_size, dilation=1, padding=0, stride=stride)
unfold = torch.nn.Unfold(**fold_params)
fold_params2 = dict(kernel_size=(kernel_size[0] // df, kernel_size[0] // df),
dilation=1, padding=0,
stride=(stride[0] // df, stride[1] // df))
fold = torch.nn.Fold(output_size=(x.shape[2] // df, x.shape[3] // df), **fold_params2)
weighting = self.get_weighting(kernel_size[0] // df, kernel_size[1] // df, Ly, Lx, x.device).to(x.dtype)
normalization = fold(weighting).view(1, 1, h // df, w // df) # normalizes the overlap
weighting = weighting.view((1, 1, kernel_size[0] // df, kernel_size[1] // df, Ly * Lx))
else:
raise NotImplementedError
return fold, unfold, normalization, weighting
@torch.no_grad()
def get_input(self, batch, k, return_first_stage_outputs=False, force_c_encode=False,
cond_key=None, return_original_cond=False, bs=None):
x = super().get_input(batch, k)
if bs is not None:
x = x[:bs]
x = x.to(self.device)
encoder_posterior = self.encode_first_stage(x)
z = self.get_first_stage_encoding(encoder_posterior).detach()
if self.model.conditioning_key is not None:
if cond_key is None:
cond_key = self.cond_stage_key
if cond_key != self.first_stage_key:
if cond_key in ['caption', 'coordinates_bbox']:
xc = batch[cond_key]
elif cond_key == 'class_label':
xc = batch
else:
xc = super().get_input(batch, cond_key).to(self.device)
else:
xc = x
if not self.cond_stage_trainable or force_c_encode:
if isinstance(xc, dict) or isinstance(xc, list):
# import pudb; pudb.set_trace()
c = self.get_learned_conditioning(xc)
else:
c = self.get_learned_conditioning(xc.to(self.device))
else:
c = xc
if bs is not None:
c = c[:bs]
if self.use_positional_encodings:
pos_x, pos_y = self.compute_latent_shifts(batch)
ckey = __conditioning_keys__[self.model.conditioning_key]
c = {ckey: c, 'pos_x': pos_x, 'pos_y': pos_y}
else:
c = None
xc = None
if self.use_positional_encodings:
pos_x, pos_y = self.compute_latent_shifts(batch)
c = {'pos_x': pos_x, 'pos_y': pos_y}
out = [z, c]
if return_first_stage_outputs:
xrec = self.decode_first_stage(z)
out.extend([x, xrec])
if return_original_cond:
out.append(xc)
return out
@torch.no_grad()
def decode_first_stage(self, z, predict_cids=False, force_not_quantize=False):
if predict_cids:
if z.dim() == 4:
z = torch.argmax(z.exp(), dim=1).long()
z = self.first_stage_model.quantize.get_codebook_entry(z, shape=None)
z = rearrange(z, 'b h w c -> b c h w').contiguous()
z = 1. / self.scale_factor * z
if hasattr(self, "split_input_params"):
if self.split_input_params["patch_distributed_vq"]:
ks = self.split_input_params["ks"] # eg. (128, 128)
stride = self.split_input_params["stride"] # eg. (64, 64)
uf = self.split_input_params["vqf"]
bs, nc, h, w = z.shape
if ks[0] > h or ks[1] > w:
ks = (min(ks[0], h), min(ks[1], w))
print("reducing Kernel")
if stride[0] > h or stride[1] > w:
stride = (min(stride[0], h), min(stride[1], w))
print("reducing stride")
fold, unfold, normalization, weighting = self.get_fold_unfold(z, ks, stride, uf=uf)
z = unfold(z) # (bn, nc * prod(**ks), L)
# 1. Reshape to img shape
z = z.view((z.shape[0], -1, ks[0], ks[1], z.shape[-1])) # (bn, nc, ks[0], ks[1], L )
# 2. apply model loop over last dim
if isinstance(self.first_stage_model, VQModelInterface):
output_list = [self.first_stage_model.decode(z[:, :, :, :, i],
force_not_quantize=predict_cids or force_not_quantize)
for i in range(z.shape[-1])]
else:
output_list = [self.first_stage_model.decode(z[:, :, :, :, i])
for i in range(z.shape[-1])]
o = torch.stack(output_list, axis=-1) # # (bn, nc, ks[0], ks[1], L)
o = o * weighting
# Reverse 1. reshape to img shape
o = o.view((o.shape[0], -1, o.shape[-1])) # (bn, nc * ks[0] * ks[1], L)
# stitch crops together
decoded = fold(o)
decoded = decoded / normalization # norm is shape (1, 1, h, w)
return decoded
else:
if isinstance(self.first_stage_model, VQModelInterface):
return self.first_stage_model.decode(z, force_not_quantize=predict_cids or force_not_quantize)
else:
return self.first_stage_model.decode(z)
else:
if isinstance(self.first_stage_model, VQModelInterface):
return self.first_stage_model.decode(z, force_not_quantize=predict_cids or force_not_quantize)
else:
return self.first_stage_model.decode(z)
# same as above but without decorator
def differentiable_decode_first_stage(self, z, predict_cids=False, force_not_quantize=False):
if predict_cids:
if z.dim() == 4:
z = torch.argmax(z.exp(), dim=1).long()
z = self.first_stage_model.quantize.get_codebook_entry(z, shape=None)
z = rearrange(z, 'b h w c -> b c h w').contiguous()
z = 1. / self.scale_factor * z
if hasattr(self, "split_input_params"):
if self.split_input_params["patch_distributed_vq"]:
ks = self.split_input_params["ks"] # eg. (128, 128)
stride = self.split_input_params["stride"] # eg. (64, 64)
uf = self.split_input_params["vqf"]
bs, nc, h, w = z.shape
if ks[0] > h or ks[1] > w:
ks = (min(ks[0], h), min(ks[1], w))
print("reducing Kernel")
if stride[0] > h or stride[1] > w:
stride = (min(stride[0], h), min(stride[1], w))
print("reducing stride")
fold, unfold, normalization, weighting = self.get_fold_unfold(z, ks, stride, uf=uf)
z = unfold(z) # (bn, nc * prod(**ks), L)
# 1. Reshape to img shape
z = z.view((z.shape[0], -1, ks[0], ks[1], z.shape[-1])) # (bn, nc, ks[0], ks[1], L )
# 2. apply model loop over last dim
if isinstance(self.first_stage_model, VQModelInterface):
output_list = [self.first_stage_model.decode(z[:, :, :, :, i],
force_not_quantize=predict_cids or force_not_quantize)
for i in range(z.shape[-1])]
else:
output_list = [self.first_stage_model.decode(z[:, :, :, :, i])
for i in range(z.shape[-1])]
o = torch.stack(output_list, axis=-1) # # (bn, nc, ks[0], ks[1], L)
o = o * weighting
# Reverse 1. reshape to img shape
o = o.view((o.shape[0], -1, o.shape[-1])) # (bn, nc * ks[0] * ks[1], L)
# stitch crops together
decoded = fold(o)
decoded = decoded / normalization # norm is shape (1, 1, h, w)
return decoded
else:
if isinstance(self.first_stage_model, VQModelInterface):
return self.first_stage_model.decode(z, force_not_quantize=predict_cids or force_not_quantize)
else:
return self.first_stage_model.decode(z)
else:
if isinstance(self.first_stage_model, VQModelInterface):
return self.first_stage_model.decode(z, force_not_quantize=predict_cids or force_not_quantize)
else:
return self.first_stage_model.decode(z)
@torch.no_grad()
def encode_first_stage(self, x):
if hasattr(self, "split_input_params"):
if self.split_input_params["patch_distributed_vq"]:
ks = self.split_input_params["ks"] # eg. (128, 128)
stride = self.split_input_params["stride"] # eg. (64, 64)
df = self.split_input_params["vqf"]
self.split_input_params['original_image_size'] = x.shape[-2:]
bs, nc, h, w = x.shape
if ks[0] > h or ks[1] > w:
ks = (min(ks[0], h), min(ks[1], w))
print("reducing Kernel")
if stride[0] > h or stride[1] > w:
stride = (min(stride[0], h), min(stride[1], w))
print("reducing stride")
fold, unfold, normalization, weighting = self.get_fold_unfold(x, ks, stride, df=df)
z = unfold(x) # (bn, nc * prod(**ks), L)
# Reshape to img shape
z = z.view((z.shape[0], -1, ks[0], ks[1], z.shape[-1])) # (bn, nc, ks[0], ks[1], L )
output_list = [self.first_stage_model.encode(z[:, :, :, :, i])
for i in range(z.shape[-1])]
o = torch.stack(output_list, axis=-1)
o = o * weighting
# Reverse reshape to img shape
o = o.view((o.shape[0], -1, o.shape[-1])) # (bn, nc * ks[0] * ks[1], L)
# stitch crops together
decoded = fold(o)
decoded = decoded / normalization
return decoded
else:
return self.first_stage_model.encode(x)
else:
return self.first_stage_model.encode(x)
def shared_step(self, batch, **kwargs):
x, c = self.get_input(batch, self.first_stage_key)
loss = self(x, c)
return loss
def forward(self, x, c, *args, **kwargs):
t = torch.randint(0, self.num_timesteps, (x.shape[0],), device=self.device).long()
if self.model.conditioning_key is not None:
assert c is not None
if self.cond_stage_trainable:
c = self.get_learned_conditioning(c)
if self.shorten_cond_schedule: # TODO: drop this option
tc = self.cond_ids[t].to(self.device)
c = self.q_sample(x_start=c, t=tc, noise=torch.randn_like(c.float()))
return self.p_losses(x, c, t, *args, **kwargs)
def _rescale_annotations(self, bboxes, crop_coordinates): # TODO: move to dataset
def rescale_bbox(bbox):
x0 = clamp((bbox[0] - crop_coordinates[0]) / crop_coordinates[2])
y0 = clamp((bbox[1] - crop_coordinates[1]) / crop_coordinates[3])
w = min(bbox[2] / crop_coordinates[2], 1 - x0)
h = min(bbox[3] / crop_coordinates[3], 1 - y0)
return x0, y0, w, h
return [rescale_bbox(b) for b in bboxes]
def apply_model(self, x_noisy, t, cond, return_ids=False):
if isinstance(cond, dict):
# hybrid case, cond is exptected to be a dict
pass
else:
if not isinstance(cond, list):
cond = [cond]
key = 'c_concat' if self.model.conditioning_key == 'concat' else 'c_crossattn'
cond = {key: cond}
if hasattr(self, "split_input_params"):
assert len(cond) == 1 # todo can only deal with one conditioning atm
assert not return_ids
ks = self.split_input_params["ks"] # eg. (128, 128)
stride = self.split_input_params["stride"] # eg. (64, 64)
h, w = x_noisy.shape[-2:]
fold, unfold, normalization, weighting = self.get_fold_unfold(x_noisy, ks, stride)
z = unfold(x_noisy) # (bn, nc * prod(**ks), L)
# Reshape to img shape
z = z.view((z.shape[0], -1, ks[0], ks[1], z.shape[-1])) # (bn, nc, ks[0], ks[1], L )
z_list = [z[:, :, :, :, i] for i in range(z.shape[-1])]
if self.cond_stage_key in ["image", "LR_image", "segmentation",
'bbox_img'] and self.model.conditioning_key: # todo check for completeness
c_key = next(iter(cond.keys())) # get key
c = next(iter(cond.values())) # get value
assert (len(c) == 1) # todo extend to list with more than one elem
c = c[0] # get element
c = unfold(c)
c = c.view((c.shape[0], -1, ks[0], ks[1], c.shape[-1])) # (bn, nc, ks[0], ks[1], L )
cond_list = [{c_key: [c[:, :, :, :, i]]} for i in range(c.shape[-1])]
elif self.cond_stage_key == 'coordinates_bbox':
assert 'original_image_size' in self.split_input_params, 'BoudingBoxRescaling is missing original_image_size'
# assuming padding of unfold is always 0 and its dilation is always 1
n_patches_per_row = int((w - ks[0]) / stride[0] + 1)
full_img_h, full_img_w = self.split_input_params['original_image_size']
# as we are operating on latents, we need the factor from the original image size to the
# spatial latent size to properly rescale the crops for regenerating the bbox annotations
num_downs = self.first_stage_model.encoder.num_resolutions - 1
rescale_latent = 2 ** (num_downs)
# get top left postions of patches as conforming for the bbbox tokenizer, therefore we
# need to rescale the tl patch coordinates to be in between (0,1)
tl_patch_coordinates = [(rescale_latent * stride[0] * (patch_nr % n_patches_per_row) / full_img_w,
rescale_latent * stride[1] * (patch_nr // n_patches_per_row) / full_img_h)
for patch_nr in range(z.shape[-1])]
# patch_limits are tl_coord, width and height coordinates as (x_tl, y_tl, h, w)
patch_limits = [(x_tl, y_tl,
rescale_latent * ks[0] / full_img_w,
rescale_latent * ks[1] / full_img_h) for x_tl, y_tl in tl_patch_coordinates]
# patch_values = [(np.arange(x_tl,min(x_tl+ks, 1.)),np.arange(y_tl,min(y_tl+ks, 1.))) for x_tl, y_tl in tl_patch_coordinates]
# tokenize crop coordinates for the bounding boxes of the respective patches
patch_limits_tknzd = [torch.LongTensor(self.bbox_tokenizer._crop_encoder(bbox))[None].to(self.device)
for bbox in patch_limits] # list of length l with tensors of shape (1, 2)
print(patch_limits_tknzd[0].shape)
# cut tknzd crop position from conditioning
assert isinstance(cond, dict), 'cond must be dict to be fed into model'
cut_cond = cond['c_crossattn'][0][..., :-2].to(self.device)
print(cut_cond.shape)
adapted_cond = torch.stack([torch.cat([cut_cond, p], dim=1) for p in patch_limits_tknzd])
adapted_cond = rearrange(adapted_cond, 'l b n -> (l b) n')
print(adapted_cond.shape)
adapted_cond = self.get_learned_conditioning(adapted_cond)
print(adapted_cond.shape)
adapted_cond = rearrange(adapted_cond, '(l b) n d -> l b n d', l=z.shape[-1])
print(adapted_cond.shape)
cond_list = [{'c_crossattn': [e]} for e in adapted_cond]
else:
cond_list = [cond for i in range(z.shape[-1])] # Todo make this more efficient
# apply model by loop over crops
output_list = [self.model(z_list[i], t, **cond_list[i]) for i in range(z.shape[-1])]
assert not isinstance(output_list[0],
tuple) # todo cant deal with multiple model outputs check this never happens
o = torch.stack(output_list, axis=-1)
o = o * weighting
# Reverse reshape to img shape
o = o.view((o.shape[0], -1, o.shape[-1])) # (bn, nc * ks[0] * ks[1], L)
# stitch crops together
x_recon = fold(o) / normalization
else:
x_recon = self.model(x_noisy, t, **cond)
if isinstance(x_recon, tuple) and not return_ids:
return x_recon[0]
else:
return x_recon
def _predict_eps_from_xstart(self, x_t, t, pred_xstart):
return (extract_into_tensor(self.sqrt_recip_alphas_cumprod, t, x_t.shape) * x_t - pred_xstart) / \
extract_into_tensor(self.sqrt_recipm1_alphas_cumprod, t, x_t.shape)
def _prior_bpd(self, x_start):
"""
Get the prior KL term for the variational lower-bound, measured in
bits-per-dim.
This term can't be optimized, as it only depends on the encoder.
:param x_start: the [N x C x ...] tensor of inputs.
:return: a batch of [N] KL values (in bits), one per batch element.
"""
batch_size = x_start.shape[0]
t = torch.tensor([self.num_timesteps - 1] * batch_size, device=x_start.device)
qt_mean, _, qt_log_variance = self.q_mean_variance(x_start, t)
kl_prior = normal_kl(mean1=qt_mean, logvar1=qt_log_variance, mean2=0.0, logvar2=0.0)
return mean_flat(kl_prior) / np.log(2.0)
def p_losses(self, x_start, cond, t, noise=None):
noise = default(noise, lambda: torch.randn_like(x_start))
x_noisy = self.q_sample(x_start=x_start, t=t, noise=noise)
model_output = self.apply_model(x_noisy, t, cond)
loss_dict = {}
prefix = 'train' if self.training else 'val'
if self.parameterization == "x0":
target = x_start
elif self.parameterization == "eps":
target = noise
else:
raise NotImplementedError()
loss_simple = self.get_loss(model_output, target, mean=False).mean([1, 2, 3])
loss_dict.update({f'{prefix}/loss_simple': loss_simple.mean()})
logvar_t = self.logvar[t].to(self.device)
loss = loss_simple / torch.exp(logvar_t) + logvar_t
# loss = loss_simple / torch.exp(self.logvar) + self.logvar
if self.learn_logvar:
loss_dict.update({f'{prefix}/loss_gamma': loss.mean()})
loss_dict.update({'logvar': self.logvar.data.mean()})
loss = self.l_simple_weight * loss.mean()
loss_vlb = self.get_loss(model_output, target, mean=False).mean(dim=(1, 2, 3))
loss_vlb = (self.lvlb_weights[t] * loss_vlb).mean()
loss_dict.update({f'{prefix}/loss_vlb': loss_vlb})
loss += (self.original_elbo_weight * loss_vlb)
loss_dict.update({f'{prefix}/loss': loss})
return loss, loss_dict
def p_mean_variance(self, x, c, t, clip_denoised: bool, return_codebook_ids=False, quantize_denoised=False,
return_x0=False, score_corrector=None, corrector_kwargs=None):
t_in = t
model_out = self.apply_model(x, t_in, c, return_ids=return_codebook_ids)
if score_corrector is not None:
assert self.parameterization == "eps"
model_out = score_corrector.modify_score(self, model_out, x, t, c, **corrector_kwargs)
if return_codebook_ids:
model_out, logits = model_out
if self.parameterization == "eps":
x_recon = self.predict_start_from_noise(x, t=t, noise=model_out)
elif self.parameterization == "x0":
x_recon = model_out
else:
raise NotImplementedError()
if clip_denoised:
x_recon.clamp_(-1., 1.)
if quantize_denoised:
x_recon, _, [_, _, indices] = self.first_stage_model.quantize(x_recon)
model_mean, posterior_variance, posterior_log_variance = self.q_posterior(x_start=x_recon, x_t=x, t=t)
if return_codebook_ids:
return model_mean, posterior_variance, posterior_log_variance, logits
elif return_x0:
return model_mean, posterior_variance, posterior_log_variance, x_recon
else:
return model_mean, posterior_variance, posterior_log_variance
@torch.no_grad()
def p_sample(self, x, c, t, clip_denoised=False, repeat_noise=False,
return_codebook_ids=False, quantize_denoised=False, return_x0=False,
temperature=1., noise_dropout=0., score_corrector=None, corrector_kwargs=None):
b, *_, device = *x.shape, x.device
outputs = self.p_mean_variance(x=x, c=c, t=t, clip_denoised=clip_denoised,
return_codebook_ids=return_codebook_ids,
quantize_denoised=quantize_denoised,
return_x0=return_x0,
score_corrector=score_corrector, corrector_kwargs=corrector_kwargs)
if return_codebook_ids:
raise DeprecationWarning("Support dropped.")
model_mean, _, model_log_variance, logits = outputs
elif return_x0:
model_mean, _, model_log_variance, x0 = outputs
else:
model_mean, _, model_log_variance = outputs
noise = noise_like(x.shape, device, repeat_noise) * temperature
if noise_dropout > 0.:
noise = torch.nn.functional.dropout(noise, p=noise_dropout)
# no noise when t == 0
nonzero_mask = (1 - (t == 0).float()).reshape(b, *((1,) * (len(x.shape) - 1)))
if return_codebook_ids:
return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, logits.argmax(dim=1)
if return_x0:
return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise, x0
else:
return model_mean + nonzero_mask * (0.5 * model_log_variance).exp() * noise
@torch.no_grad()
def progressive_denoising(self, cond, shape, verbose=True, callback=None, quantize_denoised=False,
img_callback=None, mask=None, x0=None, temperature=1., noise_dropout=0.,
score_corrector=None, corrector_kwargs=None, batch_size=None, x_T=None, start_T=None,
log_every_t=None):
if not log_every_t:
log_every_t = self.log_every_t
timesteps = self.num_timesteps
if batch_size is not None:
b = batch_size if batch_size is not None else shape[0]
shape = [batch_size] + list(shape)
else:
b = batch_size = shape[0]
if x_T is None:
img = torch.randn(shape, device=self.device)
else:
img = x_T
intermediates = []
if cond is not None:
if isinstance(cond, dict):
cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else
list(map(lambda x: x[:batch_size], cond[key])) for key in cond}
else:
cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]
if start_T is not None:
timesteps = min(timesteps, start_T)
iterator = tqdm(reversed(range(0, timesteps)), desc='Progressive Generation',
total=timesteps) if verbose else reversed(
range(0, timesteps))
if type(temperature) == float:
temperature = [temperature] * timesteps
for i in iterator:
ts = torch.full((b,), i, device=self.device, dtype=torch.long)
if self.shorten_cond_schedule:
assert self.model.conditioning_key != 'hybrid'
tc = self.cond_ids[ts].to(cond.device)
cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))
img, x0_partial = self.p_sample(img, cond, ts,
clip_denoised=self.clip_denoised,
quantize_denoised=quantize_denoised, return_x0=True,
temperature=temperature[i], noise_dropout=noise_dropout,
score_corrector=score_corrector, corrector_kwargs=corrector_kwargs)
if mask is not None:
assert x0 is not None
img_orig = self.q_sample(x0, ts)
img = img_orig * mask + (1. - mask) * img
if i % log_every_t == 0 or i == timesteps - 1:
intermediates.append(x0_partial)
if callback: callback(i)
if img_callback: img_callback(img, i)
return img, intermediates
@torch.no_grad()
def p_sample_loop(self, cond, shape, return_intermediates=False,
x_T=None, verbose=True, callback=None, timesteps=None, quantize_denoised=False,
mask=None, x0=None, img_callback=None, start_T=None,
log_every_t=None):
if not log_every_t:
log_every_t = self.log_every_t
device = self.betas.device
b = shape[0]
if x_T is None:
img = torch.randn(shape, device=device)
else:
img = x_T
intermediates = [img]
if timesteps is None:
timesteps = self.num_timesteps
if start_T is not None:
timesteps = min(timesteps, start_T)
iterator = tqdm(reversed(range(0, timesteps)), desc='Sampling t', total=timesteps) if verbose else reversed(
range(0, timesteps))
if mask is not None:
assert x0 is not None
assert x0.shape[2:3] == mask.shape[2:3] # spatial size has to match
for i in iterator:
ts = torch.full((b,), i, device=device, dtype=torch.long)
if self.shorten_cond_schedule:
assert self.model.conditioning_key != 'hybrid'
tc = self.cond_ids[ts].to(cond.device)
cond = self.q_sample(x_start=cond, t=tc, noise=torch.randn_like(cond))
img = self.p_sample(img, cond, ts,
clip_denoised=self.clip_denoised,
quantize_denoised=quantize_denoised)
if mask is not None:
img_orig = self.q_sample(x0, ts)
img = img_orig * mask + (1. - mask) * img
if i % log_every_t == 0 or i == timesteps - 1:
intermediates.append(img)
if callback: callback(i)
if img_callback: img_callback(img, i)
if return_intermediates:
return img, intermediates
return img
@torch.no_grad()
def sample(self, cond, batch_size=16, return_intermediates=False, x_T=None,
verbose=True, timesteps=None, quantize_denoised=False,
mask=None, x0=None, shape=None,**kwargs):
if shape is None:
shape = (batch_size, self.channels, self.image_size, self.image_size)
if cond is not None:
if isinstance(cond, dict):
cond = {key: cond[key][:batch_size] if not isinstance(cond[key], list) else
list(map(lambda x: x[:batch_size], cond[key])) for key in cond}
else:
cond = [c[:batch_size] for c in cond] if isinstance(cond, list) else cond[:batch_size]
return self.p_sample_loop(cond,
shape,
return_intermediates=return_intermediates, x_T=x_T,
verbose=verbose, timesteps=timesteps, quantize_denoised=quantize_denoised,
mask=mask, x0=x0)
@torch.no_grad()
def sample_log(self,cond,batch_size,ddim, ddim_steps,**kwargs):
if ddim:
ddim_sampler = DDIMSampler(self)
shape = (self.channels, self.image_size, self.image_size)
samples, intermediates =ddim_sampler.sample(ddim_steps,batch_size,
shape,cond,verbose=False,**kwargs)
else:
samples, intermediates = self.sample(cond=cond, batch_size=batch_size,
return_intermediates=True,**kwargs)
return samples, intermediates
@torch.no_grad()
def log_images(self, batch, N=8, n_row=4, sample=True, ddim_steps=200, ddim_eta=1., return_keys=None,
quantize_denoised=True, inpaint=True, plot_denoise_rows=False, plot_progressive_rows=True,
plot_diffusion_rows=True, **kwargs):
use_ddim = ddim_steps is not None
log = dict()
z, c, x, xrec, xc = self.get_input(batch, self.first_stage_key,
return_first_stage_outputs=True,
force_c_encode=True,
return_original_cond=True,
bs=N)
N = min(x.shape[0], N)
n_row = min(x.shape[0], n_row)
log["inputs"] = x
log["reconstruction"] = xrec
if self.model.conditioning_key is not None:
if hasattr(self.cond_stage_model, "decode"):
xc = self.cond_stage_model.decode(c)
log["conditioning"] = xc
elif self.cond_stage_key in ["caption"]:
xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["caption"])
log["conditioning"] = xc
elif self.cond_stage_key == 'class_label':
xc = log_txt_as_img((x.shape[2], x.shape[3]), batch["human_label"])
log['conditioning'] = xc
elif isimage(xc):
log["conditioning"] = xc
if ismap(xc):
log["original_conditioning"] = self.to_rgb(xc)
if plot_diffusion_rows:
# get diffusion row
diffusion_row = list()
z_start = z[:n_row]
for t in range(self.num_timesteps):
if t % self.log_every_t == 0 or t == self.num_timesteps - 1:
t = repeat(torch.tensor([t]), '1 -> b', b=n_row)
t = t.to(self.device).long()
noise = torch.randn_like(z_start)
z_noisy = self.q_sample(x_start=z_start, t=t, noise=noise)
diffusion_row.append(self.decode_first_stage(z_noisy))
diffusion_row = torch.stack(diffusion_row) # n_log_step, n_row, C, H, W
diffusion_grid = rearrange(diffusion_row, 'n b c h w -> b n c h w')
diffusion_grid = rearrange(diffusion_grid, 'b n c h w -> (b n) c h w')
diffusion_grid = make_grid(diffusion_grid, nrow=diffusion_row.shape[0])
log["diffusion_row"] = diffusion_grid
if sample:
# get denoise row
with self.ema_scope("Plotting"):
samples, z_denoise_row = self.sample_log(cond=c,batch_size=N,ddim=use_ddim,
ddim_steps=ddim_steps,eta=ddim_eta)
# samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True)
x_samples = self.decode_first_stage(samples)
log["samples"] = x_samples
if plot_denoise_rows:
denoise_grid = self._get_denoise_row_from_list(z_denoise_row)
log["denoise_row"] = denoise_grid
if quantize_denoised and not isinstance(self.first_stage_model, AutoencoderKL) and not isinstance(
self.first_stage_model, IdentityFirstStage):
# also display when quantizing x0 while sampling
with self.ema_scope("Plotting Quantized Denoised"):
samples, z_denoise_row = self.sample_log(cond=c,batch_size=N,ddim=use_ddim,
ddim_steps=ddim_steps,eta=ddim_eta,
quantize_denoised=True)
# samples, z_denoise_row = self.sample(cond=c, batch_size=N, return_intermediates=True,
# quantize_denoised=True)
x_samples = self.decode_first_stage(samples.to(self.device))
log["samples_x0_quantized"] = x_samples
if inpaint:
# make a simple center square
b, h, w = z.shape[0], z.shape[2], z.shape[3]
mask = torch.ones(N, h, w).to(self.device)
# zeros will be filled in
mask[:, h // 4:3 * h // 4, w // 4:3 * w // 4] = 0.
mask = mask[:, None, ...]
with self.ema_scope("Plotting Inpaint"):
samples, _ = self.sample_log(cond=c,batch_size=N,ddim=use_ddim, eta=ddim_eta,
ddim_steps=ddim_steps, x0=z[:N], mask=mask)
x_samples = self.decode_first_stage(samples.to(self.device))
log["samples_inpainting"] = x_samples
log["mask"] = mask
# outpaint
with self.ema_scope("Plotting Outpaint"):
samples, _ = self.sample_log(cond=c, batch_size=N, ddim=use_ddim,eta=ddim_eta,
ddim_steps=ddim_steps, x0=z[:N], mask=mask)
x_samples = self.decode_first_stage(samples.to(self.device))
log["samples_outpainting"] = x_samples
if plot_progressive_rows:
with self.ema_scope("Plotting Progressives"):
img, progressives = self.progressive_denoising(c,
shape=(self.channels, self.image_size, self.image_size),
batch_size=N)
prog_row = self._get_denoise_row_from_list(progressives, desc="Progressive Generation")
log["progressive_row"] = prog_row
if return_keys:
if np.intersect1d(list(log.keys()), return_keys).shape[0] == 0:
return log
else:
return {key: log[key] for key in return_keys}
return log
def configure_optimizers(self):
lr = self.learning_rate
params = list(self.model.parameters())
if self.cond_stage_trainable:
print(f"{self.__class__.__name__}: Also optimizing conditioner params!")
params = params + list(self.cond_stage_model.parameters())
if self.learn_logvar:
print('Diffusion model optimizing logvar')
params.append(self.logvar)
opt = torch.optim.AdamW(params, lr=lr)
if self.use_scheduler:
assert 'target' in self.scheduler_config
scheduler = instantiate_from_config(self.scheduler_config)
print("Setting up LambdaLR scheduler...")
scheduler = [
{
'scheduler': LambdaLR(opt, lr_lambda=scheduler.schedule),
'interval': 'step',
'frequency': 1
}]
return [opt], scheduler
return opt
@torch.no_grad()
def to_rgb(self, x):
x = x.float()
if not hasattr(self, "colorize"):
self.colorize = torch.randn(3, x.shape[1], 1, 1).to(x)
x = nn.functional.conv2d(x, weight=self.colorize)
x = 2. * (x - x.min()) / (x.max() - x.min()) - 1.
return x
class DiffusionWrapper(pl.LightningModule):
def __init__(self, diff_model_config, conditioning_key):
super().__init__()
self.diffusion_model = instantiate_from_config(diff_model_config)
self.conditioning_key = conditioning_key
assert self.conditioning_key in [None, 'concat', 'crossattn', 'hybrid', 'adm']
def forward(self, x, t, c_concat: list = None, c_crossattn: list = None):
if self.conditioning_key is None:
out = self.diffusion_model(x, t)
elif self.conditioning_key == 'concat':
xc = torch.cat([x] + c_concat, dim=1)
out = self.diffusion_model(xc, t)
elif self.conditioning_key == 'crossattn':
cc = torch.cat(c_crossattn, 1)
out = self.diffusion_model(x, t, context=cc)
elif self.conditioning_key == 'hybrid':
xc = torch.cat([x] + c_concat, dim=1)
cc = torch.cat(c_crossattn, 1)
out = self.diffusion_model(xc, t, context=cc)
elif self.conditioning_key == 'adm':
cc = c_crossattn[0]
out = self.diffusion_model(x, t, y=cc)
else:
raise NotImplementedError()
return out
class Layout2ImgDiffusion(LatentDiffusion):
# TODO: move all layout-specific hacks to this class
def __init__(self, cond_stage_key, *args, **kwargs):
assert cond_stage_key == 'coordinates_bbox', 'Layout2ImgDiffusion only for cond_stage_key="coordinates_bbox"'
super().__init__(cond_stage_key=cond_stage_key, *args, **kwargs)
def log_images(self, batch, N=8, *args, **kwargs):
logs = super().log_images(batch=batch, N=N, *args, **kwargs)
key = 'train' if self.training else 'validation'
dset = self.trainer.datamodule.datasets[key]
mapper = dset.conditional_builders[self.cond_stage_key]
bbox_imgs = []
map_fn = lambda catno: dset.get_textual_label(dset.get_category_id(catno))
for tknzd_bbox in batch[self.cond_stage_key][:N]:
bboximg = mapper.plot(tknzd_bbox.detach().cpu(), map_fn, (256, 256))
bbox_imgs.append(bboximg)
cond_img = torch.stack(bbox_imgs, dim=0)
logs['bbox_image'] = cond_img
return logs
| EXA-1-master | exa/libraries/latent-diffusion/ldm/models/diffusion/ddpm.py |
from inspect import isfunction
import math
import torch
import torch.nn.functional as F
from torch import nn, einsum
from einops import rearrange, repeat
from ldm.modules.diffusionmodules.util import checkpoint
def exists(val):
return val is not None
def uniq(arr):
return{el: True for el in arr}.keys()
def default(val, d):
if exists(val):
return val
return d() if isfunction(d) else d
def max_neg_value(t):
return -torch.finfo(t.dtype).max
def init_(tensor):
dim = tensor.shape[-1]
std = 1 / math.sqrt(dim)
tensor.uniform_(-std, std)
return tensor
# feedforward
class GEGLU(nn.Module):
def __init__(self, dim_in, dim_out):
super().__init__()
self.proj = nn.Linear(dim_in, dim_out * 2)
def forward(self, x):
x, gate = self.proj(x).chunk(2, dim=-1)
return x * F.gelu(gate)
class FeedForward(nn.Module):
def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.):
super().__init__()
inner_dim = int(dim * mult)
dim_out = default(dim_out, dim)
project_in = nn.Sequential(
nn.Linear(dim, inner_dim),
nn.GELU()
) if not glu else GEGLU(dim, inner_dim)
self.net = nn.Sequential(
project_in,
nn.Dropout(dropout),
nn.Linear(inner_dim, dim_out)
)
def forward(self, x):
return self.net(x)
def zero_module(module):
"""
Zero out the parameters of a module and return it.
"""
for p in module.parameters():
p.detach().zero_()
return module
def Normalize(in_channels):
return torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)
class LinearAttention(nn.Module):
def __init__(self, dim, heads=4, dim_head=32):
super().__init__()
self.heads = heads
hidden_dim = dim_head * heads
self.to_qkv = nn.Conv2d(dim, hidden_dim * 3, 1, bias = False)
self.to_out = nn.Conv2d(hidden_dim, dim, 1)
def forward(self, x):
b, c, h, w = x.shape
qkv = self.to_qkv(x)
q, k, v = rearrange(qkv, 'b (qkv heads c) h w -> qkv b heads c (h w)', heads = self.heads, qkv=3)
k = k.softmax(dim=-1)
context = torch.einsum('bhdn,bhen->bhde', k, v)
out = torch.einsum('bhde,bhdn->bhen', context, q)
out = rearrange(out, 'b heads c (h w) -> b (heads c) h w', heads=self.heads, h=h, w=w)
return self.to_out(out)
class SpatialSelfAttention(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 = rearrange(q, 'b c h w -> b (h w) c')
k = rearrange(k, 'b c h w -> b c (h w)')
w_ = torch.einsum('bij,bjk->bik', q, k)
w_ = w_ * (int(c)**(-0.5))
w_ = torch.nn.functional.softmax(w_, dim=2)
# attend to values
v = rearrange(v, 'b c h w -> b c (h w)')
w_ = rearrange(w_, 'b i j -> b j i')
h_ = torch.einsum('bij,bjk->bik', v, w_)
h_ = rearrange(h_, 'b c (h w) -> b c h w', h=h)
h_ = self.proj_out(h_)
return x+h_
class CrossAttention(nn.Module):
def __init__(self, query_dim, context_dim=None, heads=8, dim_head=64, dropout=0.):
super().__init__()
inner_dim = dim_head * heads
context_dim = default(context_dim, query_dim)
self.scale = dim_head ** -0.5
self.heads = heads
self.to_q = nn.Linear(query_dim, inner_dim, bias=False)
self.to_k = nn.Linear(context_dim, inner_dim, bias=False)
self.to_v = nn.Linear(context_dim, inner_dim, bias=False)
self.to_out = nn.Sequential(
nn.Linear(inner_dim, query_dim),
nn.Dropout(dropout)
)
def forward(self, x, context=None, mask=None):
h = self.heads
q = self.to_q(x)
context = default(context, x)
k = self.to_k(context)
v = self.to_v(context)
q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> (b h) n d', h=h), (q, k, v))
sim = einsum('b i d, b j d -> b i j', q, k) * self.scale
if exists(mask):
mask = rearrange(mask, 'b ... -> b (...)')
max_neg_value = -torch.finfo(sim.dtype).max
mask = repeat(mask, 'b j -> (b h) () j', h=h)
sim.masked_fill_(~mask, max_neg_value)
# attention, what we cannot get enough of
attn = sim.softmax(dim=-1)
out = einsum('b i j, b j d -> b i d', attn, v)
out = rearrange(out, '(b h) n d -> b n (h d)', h=h)
return self.to_out(out)
class BasicTransformerBlock(nn.Module):
def __init__(self, dim, n_heads, d_head, dropout=0., context_dim=None, gated_ff=True, checkpoint=True):
super().__init__()
self.attn1 = CrossAttention(query_dim=dim, heads=n_heads, dim_head=d_head, dropout=dropout) # is a self-attention
self.ff = FeedForward(dim, dropout=dropout, glu=gated_ff)
self.attn2 = CrossAttention(query_dim=dim, context_dim=context_dim,
heads=n_heads, dim_head=d_head, dropout=dropout) # is self-attn if context is none
self.norm1 = nn.LayerNorm(dim)
self.norm2 = nn.LayerNorm(dim)
self.norm3 = nn.LayerNorm(dim)
self.checkpoint = checkpoint
def forward(self, x, context=None):
return checkpoint(self._forward, (x, context), self.parameters(), self.checkpoint)
def _forward(self, x, context=None):
x = self.attn1(self.norm1(x)) + x
x = self.attn2(self.norm2(x), context=context) + x
x = self.ff(self.norm3(x)) + x
return x
class SpatialTransformer(nn.Module):
"""
Transformer block for image-like data.
First, project the input (aka embedding)
and reshape to b, t, d.
Then apply standard transformer action.
Finally, reshape to image
"""
def __init__(self, in_channels, n_heads, d_head,
depth=1, dropout=0., context_dim=None):
super().__init__()
self.in_channels = in_channels
inner_dim = n_heads * d_head
self.norm = Normalize(in_channels)
self.proj_in = nn.Conv2d(in_channels,
inner_dim,
kernel_size=1,
stride=1,
padding=0)
self.transformer_blocks = nn.ModuleList(
[BasicTransformerBlock(inner_dim, n_heads, d_head, dropout=dropout, context_dim=context_dim)
for d in range(depth)]
)
self.proj_out = zero_module(nn.Conv2d(inner_dim,
in_channels,
kernel_size=1,
stride=1,
padding=0))
def forward(self, x, context=None):
# note: if no context is given, cross-attention defaults to self-attention
b, c, h, w = x.shape
x_in = x
x = self.norm(x)
x = self.proj_in(x)
x = rearrange(x, 'b c h w -> b (h w) c')
for block in self.transformer_blocks:
x = block(x, context=context)
x = rearrange(x, 'b (h w) c -> b c h w', h=h, w=w)
x = self.proj_out(x)
return x + x_in | EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/attention.py |
"""shout-out to https://github.com/lucidrains/x-transformers/tree/main/x_transformers"""
import torch
from torch import nn, einsum
import torch.nn.functional as F
from functools import partial
from inspect import isfunction
from collections import namedtuple
from einops import rearrange, repeat, reduce
# constants
DEFAULT_DIM_HEAD = 64
Intermediates = namedtuple('Intermediates', [
'pre_softmax_attn',
'post_softmax_attn'
])
LayerIntermediates = namedtuple('Intermediates', [
'hiddens',
'attn_intermediates'
])
class AbsolutePositionalEmbedding(nn.Module):
def __init__(self, dim, max_seq_len):
super().__init__()
self.emb = nn.Embedding(max_seq_len, dim)
self.init_()
def init_(self):
nn.init.normal_(self.emb.weight, std=0.02)
def forward(self, x):
n = torch.arange(x.shape[1], device=x.device)
return self.emb(n)[None, :, :]
class FixedPositionalEmbedding(nn.Module):
def __init__(self, dim):
super().__init__()
inv_freq = 1. / (10000 ** (torch.arange(0, dim, 2).float() / dim))
self.register_buffer('inv_freq', inv_freq)
def forward(self, x, seq_dim=1, offset=0):
t = torch.arange(x.shape[seq_dim], device=x.device).type_as(self.inv_freq) + offset
sinusoid_inp = torch.einsum('i , j -> i j', t, self.inv_freq)
emb = torch.cat((sinusoid_inp.sin(), sinusoid_inp.cos()), dim=-1)
return emb[None, :, :]
# helpers
def exists(val):
return val is not None
def default(val, d):
if exists(val):
return val
return d() if isfunction(d) else d
def always(val):
def inner(*args, **kwargs):
return val
return inner
def not_equals(val):
def inner(x):
return x != val
return inner
def equals(val):
def inner(x):
return x == val
return inner
def max_neg_value(tensor):
return -torch.finfo(tensor.dtype).max
# keyword argument helpers
def pick_and_pop(keys, d):
values = list(map(lambda key: d.pop(key), keys))
return dict(zip(keys, values))
def group_dict_by_key(cond, d):
return_val = [dict(), dict()]
for key in d.keys():
match = bool(cond(key))
ind = int(not match)
return_val[ind][key] = d[key]
return (*return_val,)
def string_begins_with(prefix, str):
return str.startswith(prefix)
def group_by_key_prefix(prefix, d):
return group_dict_by_key(partial(string_begins_with, prefix), d)
def groupby_prefix_and_trim(prefix, d):
kwargs_with_prefix, kwargs = group_dict_by_key(partial(string_begins_with, prefix), d)
kwargs_without_prefix = dict(map(lambda x: (x[0][len(prefix):], x[1]), tuple(kwargs_with_prefix.items())))
return kwargs_without_prefix, kwargs
# classes
class Scale(nn.Module):
def __init__(self, value, fn):
super().__init__()
self.value = value
self.fn = fn
def forward(self, x, **kwargs):
x, *rest = self.fn(x, **kwargs)
return (x * self.value, *rest)
class Rezero(nn.Module):
def __init__(self, fn):
super().__init__()
self.fn = fn
self.g = nn.Parameter(torch.zeros(1))
def forward(self, x, **kwargs):
x, *rest = self.fn(x, **kwargs)
return (x * self.g, *rest)
class ScaleNorm(nn.Module):
def __init__(self, dim, eps=1e-5):
super().__init__()
self.scale = dim ** -0.5
self.eps = eps
self.g = nn.Parameter(torch.ones(1))
def forward(self, x):
norm = torch.norm(x, dim=-1, keepdim=True) * self.scale
return x / norm.clamp(min=self.eps) * self.g
class RMSNorm(nn.Module):
def __init__(self, dim, eps=1e-8):
super().__init__()
self.scale = dim ** -0.5
self.eps = eps
self.g = nn.Parameter(torch.ones(dim))
def forward(self, x):
norm = torch.norm(x, dim=-1, keepdim=True) * self.scale
return x / norm.clamp(min=self.eps) * self.g
class Residual(nn.Module):
def forward(self, x, residual):
return x + residual
class GRUGating(nn.Module):
def __init__(self, dim):
super().__init__()
self.gru = nn.GRUCell(dim, dim)
def forward(self, x, residual):
gated_output = self.gru(
rearrange(x, 'b n d -> (b n) d'),
rearrange(residual, 'b n d -> (b n) d')
)
return gated_output.reshape_as(x)
# feedforward
class GEGLU(nn.Module):
def __init__(self, dim_in, dim_out):
super().__init__()
self.proj = nn.Linear(dim_in, dim_out * 2)
def forward(self, x):
x, gate = self.proj(x).chunk(2, dim=-1)
return x * F.gelu(gate)
class FeedForward(nn.Module):
def __init__(self, dim, dim_out=None, mult=4, glu=False, dropout=0.):
super().__init__()
inner_dim = int(dim * mult)
dim_out = default(dim_out, dim)
project_in = nn.Sequential(
nn.Linear(dim, inner_dim),
nn.GELU()
) if not glu else GEGLU(dim, inner_dim)
self.net = nn.Sequential(
project_in,
nn.Dropout(dropout),
nn.Linear(inner_dim, dim_out)
)
def forward(self, x):
return self.net(x)
# attention.
class Attention(nn.Module):
def __init__(
self,
dim,
dim_head=DEFAULT_DIM_HEAD,
heads=8,
causal=False,
mask=None,
talking_heads=False,
sparse_topk=None,
use_entmax15=False,
num_mem_kv=0,
dropout=0.,
on_attn=False
):
super().__init__()
if use_entmax15:
raise NotImplementedError("Check out entmax activation instead of softmax activation!")
self.scale = dim_head ** -0.5
self.heads = heads
self.causal = causal
self.mask = mask
inner_dim = dim_head * heads
self.to_q = nn.Linear(dim, inner_dim, bias=False)
self.to_k = nn.Linear(dim, inner_dim, bias=False)
self.to_v = nn.Linear(dim, inner_dim, bias=False)
self.dropout = nn.Dropout(dropout)
# talking heads
self.talking_heads = talking_heads
if talking_heads:
self.pre_softmax_proj = nn.Parameter(torch.randn(heads, heads))
self.post_softmax_proj = nn.Parameter(torch.randn(heads, heads))
# explicit topk sparse attention
self.sparse_topk = sparse_topk
# entmax
#self.attn_fn = entmax15 if use_entmax15 else F.softmax
self.attn_fn = F.softmax
# add memory key / values
self.num_mem_kv = num_mem_kv
if num_mem_kv > 0:
self.mem_k = nn.Parameter(torch.randn(heads, num_mem_kv, dim_head))
self.mem_v = nn.Parameter(torch.randn(heads, num_mem_kv, dim_head))
# attention on attention
self.attn_on_attn = on_attn
self.to_out = nn.Sequential(nn.Linear(inner_dim, dim * 2), nn.GLU()) if on_attn else nn.Linear(inner_dim, dim)
def forward(
self,
x,
context=None,
mask=None,
context_mask=None,
rel_pos=None,
sinusoidal_emb=None,
prev_attn=None,
mem=None
):
b, n, _, h, talking_heads, device = *x.shape, self.heads, self.talking_heads, x.device
kv_input = default(context, x)
q_input = x
k_input = kv_input
v_input = kv_input
if exists(mem):
k_input = torch.cat((mem, k_input), dim=-2)
v_input = torch.cat((mem, v_input), dim=-2)
if exists(sinusoidal_emb):
# in shortformer, the query would start at a position offset depending on the past cached memory
offset = k_input.shape[-2] - q_input.shape[-2]
q_input = q_input + sinusoidal_emb(q_input, offset=offset)
k_input = k_input + sinusoidal_emb(k_input)
q = self.to_q(q_input)
k = self.to_k(k_input)
v = self.to_v(v_input)
q, k, v = map(lambda t: rearrange(t, 'b n (h d) -> b h n d', h=h), (q, k, v))
input_mask = None
if any(map(exists, (mask, context_mask))):
q_mask = default(mask, lambda: torch.ones((b, n), device=device).bool())
k_mask = q_mask if not exists(context) else context_mask
k_mask = default(k_mask, lambda: torch.ones((b, k.shape[-2]), device=device).bool())
q_mask = rearrange(q_mask, 'b i -> b () i ()')
k_mask = rearrange(k_mask, 'b j -> b () () j')
input_mask = q_mask * k_mask
if self.num_mem_kv > 0:
mem_k, mem_v = map(lambda t: repeat(t, 'h n d -> b h n d', b=b), (self.mem_k, self.mem_v))
k = torch.cat((mem_k, k), dim=-2)
v = torch.cat((mem_v, v), dim=-2)
if exists(input_mask):
input_mask = F.pad(input_mask, (self.num_mem_kv, 0), value=True)
dots = einsum('b h i d, b h j d -> b h i j', q, k) * self.scale
mask_value = max_neg_value(dots)
if exists(prev_attn):
dots = dots + prev_attn
pre_softmax_attn = dots
if talking_heads:
dots = einsum('b h i j, h k -> b k i j', dots, self.pre_softmax_proj).contiguous()
if exists(rel_pos):
dots = rel_pos(dots)
if exists(input_mask):
dots.masked_fill_(~input_mask, mask_value)
del input_mask
if self.causal:
i, j = dots.shape[-2:]
r = torch.arange(i, device=device)
mask = rearrange(r, 'i -> () () i ()') < rearrange(r, 'j -> () () () j')
mask = F.pad(mask, (j - i, 0), value=False)
dots.masked_fill_(mask, mask_value)
del mask
if exists(self.sparse_topk) and self.sparse_topk < dots.shape[-1]:
top, _ = dots.topk(self.sparse_topk, dim=-1)
vk = top[..., -1].unsqueeze(-1).expand_as(dots)
mask = dots < vk
dots.masked_fill_(mask, mask_value)
del mask
attn = self.attn_fn(dots, dim=-1)
post_softmax_attn = attn
attn = self.dropout(attn)
if talking_heads:
attn = einsum('b h i j, h k -> b k i j', attn, self.post_softmax_proj).contiguous()
out = einsum('b h i j, b h j d -> b h i d', attn, v)
out = rearrange(out, 'b h n d -> b n (h d)')
intermediates = Intermediates(
pre_softmax_attn=pre_softmax_attn,
post_softmax_attn=post_softmax_attn
)
return self.to_out(out), intermediates
class AttentionLayers(nn.Module):
def __init__(
self,
dim,
depth,
heads=8,
causal=False,
cross_attend=False,
only_cross=False,
use_scalenorm=False,
use_rmsnorm=False,
use_rezero=False,
rel_pos_num_buckets=32,
rel_pos_max_distance=128,
position_infused_attn=False,
custom_layers=None,
sandwich_coef=None,
par_ratio=None,
residual_attn=False,
cross_residual_attn=False,
macaron=False,
pre_norm=True,
gate_residual=False,
**kwargs
):
super().__init__()
ff_kwargs, kwargs = groupby_prefix_and_trim('ff_', kwargs)
attn_kwargs, _ = groupby_prefix_and_trim('attn_', kwargs)
dim_head = attn_kwargs.get('dim_head', DEFAULT_DIM_HEAD)
self.dim = dim
self.depth = depth
self.layers = nn.ModuleList([])
self.has_pos_emb = position_infused_attn
self.pia_pos_emb = FixedPositionalEmbedding(dim) if position_infused_attn else None
self.rotary_pos_emb = always(None)
assert rel_pos_num_buckets <= rel_pos_max_distance, 'number of relative position buckets must be less than the relative position max distance'
self.rel_pos = None
self.pre_norm = pre_norm
self.residual_attn = residual_attn
self.cross_residual_attn = cross_residual_attn
norm_class = ScaleNorm if use_scalenorm else nn.LayerNorm
norm_class = RMSNorm if use_rmsnorm else norm_class
norm_fn = partial(norm_class, dim)
norm_fn = nn.Identity if use_rezero else norm_fn
branch_fn = Rezero if use_rezero else None
if cross_attend and not only_cross:
default_block = ('a', 'c', 'f')
elif cross_attend and only_cross:
default_block = ('c', 'f')
else:
default_block = ('a', 'f')
if macaron:
default_block = ('f',) + default_block
if exists(custom_layers):
layer_types = custom_layers
elif exists(par_ratio):
par_depth = depth * len(default_block)
assert 1 < par_ratio <= par_depth, 'par ratio out of range'
default_block = tuple(filter(not_equals('f'), default_block))
par_attn = par_depth // par_ratio
depth_cut = par_depth * 2 // 3 # 2 / 3 attention layer cutoff suggested by PAR paper
par_width = (depth_cut + depth_cut // par_attn) // par_attn
assert len(default_block) <= par_width, 'default block is too large for par_ratio'
par_block = default_block + ('f',) * (par_width - len(default_block))
par_head = par_block * par_attn
layer_types = par_head + ('f',) * (par_depth - len(par_head))
elif exists(sandwich_coef):
assert sandwich_coef > 0 and sandwich_coef <= depth, 'sandwich coefficient should be less than the depth'
layer_types = ('a',) * sandwich_coef + default_block * (depth - sandwich_coef) + ('f',) * sandwich_coef
else:
layer_types = default_block * depth
self.layer_types = layer_types
self.num_attn_layers = len(list(filter(equals('a'), layer_types)))
for layer_type in self.layer_types:
if layer_type == 'a':
layer = Attention(dim, heads=heads, causal=causal, **attn_kwargs)
elif layer_type == 'c':
layer = Attention(dim, heads=heads, **attn_kwargs)
elif layer_type == 'f':
layer = FeedForward(dim, **ff_kwargs)
layer = layer if not macaron else Scale(0.5, layer)
else:
raise Exception(f'invalid layer type {layer_type}')
if isinstance(layer, Attention) and exists(branch_fn):
layer = branch_fn(layer)
if gate_residual:
residual_fn = GRUGating(dim)
else:
residual_fn = Residual()
self.layers.append(nn.ModuleList([
norm_fn(),
layer,
residual_fn
]))
def forward(
self,
x,
context=None,
mask=None,
context_mask=None,
mems=None,
return_hiddens=False
):
hiddens = []
intermediates = []
prev_attn = None
prev_cross_attn = None
mems = mems.copy() if exists(mems) else [None] * self.num_attn_layers
for ind, (layer_type, (norm, block, residual_fn)) in enumerate(zip(self.layer_types, self.layers)):
is_last = ind == (len(self.layers) - 1)
if layer_type == 'a':
hiddens.append(x)
layer_mem = mems.pop(0)
residual = x
if self.pre_norm:
x = norm(x)
if layer_type == 'a':
out, inter = block(x, mask=mask, sinusoidal_emb=self.pia_pos_emb, rel_pos=self.rel_pos,
prev_attn=prev_attn, mem=layer_mem)
elif layer_type == 'c':
out, inter = block(x, context=context, mask=mask, context_mask=context_mask, prev_attn=prev_cross_attn)
elif layer_type == 'f':
out = block(x)
x = residual_fn(out, residual)
if layer_type in ('a', 'c'):
intermediates.append(inter)
if layer_type == 'a' and self.residual_attn:
prev_attn = inter.pre_softmax_attn
elif layer_type == 'c' and self.cross_residual_attn:
prev_cross_attn = inter.pre_softmax_attn
if not self.pre_norm and not is_last:
x = norm(x)
if return_hiddens:
intermediates = LayerIntermediates(
hiddens=hiddens,
attn_intermediates=intermediates
)
return x, intermediates
return x
class Encoder(AttentionLayers):
def __init__(self, **kwargs):
assert 'causal' not in kwargs, 'cannot set causality on encoder'
super().__init__(causal=False, **kwargs)
class TransformerWrapper(nn.Module):
def __init__(
self,
*,
num_tokens,
max_seq_len,
attn_layers,
emb_dim=None,
max_mem_len=0.,
emb_dropout=0.,
num_memory_tokens=None,
tie_embedding=False,
use_pos_emb=True
):
super().__init__()
assert isinstance(attn_layers, AttentionLayers), 'attention layers must be one of Encoder or Decoder'
dim = attn_layers.dim
emb_dim = default(emb_dim, dim)
self.max_seq_len = max_seq_len
self.max_mem_len = max_mem_len
self.num_tokens = num_tokens
self.token_emb = nn.Embedding(num_tokens, emb_dim)
self.pos_emb = AbsolutePositionalEmbedding(emb_dim, max_seq_len) if (
use_pos_emb and not attn_layers.has_pos_emb) else always(0)
self.emb_dropout = nn.Dropout(emb_dropout)
self.project_emb = nn.Linear(emb_dim, dim) if emb_dim != dim else nn.Identity()
self.attn_layers = attn_layers
self.norm = nn.LayerNorm(dim)
self.init_()
self.to_logits = nn.Linear(dim, num_tokens) if not tie_embedding else lambda t: t @ self.token_emb.weight.t()
# memory tokens (like [cls]) from Memory Transformers paper
num_memory_tokens = default(num_memory_tokens, 0)
self.num_memory_tokens = num_memory_tokens
if num_memory_tokens > 0:
self.memory_tokens = nn.Parameter(torch.randn(num_memory_tokens, dim))
# let funnel encoder know number of memory tokens, if specified
if hasattr(attn_layers, 'num_memory_tokens'):
attn_layers.num_memory_tokens = num_memory_tokens
def init_(self):
nn.init.normal_(self.token_emb.weight, std=0.02)
def forward(
self,
x,
return_embeddings=False,
mask=None,
return_mems=False,
return_attn=False,
mems=None,
**kwargs
):
b, n, device, num_mem = *x.shape, x.device, self.num_memory_tokens
x = self.token_emb(x)
x += self.pos_emb(x)
x = self.emb_dropout(x)
x = self.project_emb(x)
if num_mem > 0:
mem = repeat(self.memory_tokens, 'n d -> b n d', b=b)
x = torch.cat((mem, x), dim=1)
# auto-handle masking after appending memory tokens
if exists(mask):
mask = F.pad(mask, (num_mem, 0), value=True)
x, intermediates = self.attn_layers(x, mask=mask, mems=mems, return_hiddens=True, **kwargs)
x = self.norm(x)
mem, x = x[:, :num_mem], x[:, num_mem:]
out = self.to_logits(x) if not return_embeddings else x
if return_mems:
hiddens = intermediates.hiddens
new_mems = list(map(lambda pair: torch.cat(pair, dim=-2), zip(mems, hiddens))) if exists(mems) else hiddens
new_mems = list(map(lambda t: t[..., -self.max_mem_len:, :].detach(), new_mems))
return out, new_mems
if return_attn:
attn_maps = list(map(lambda t: t.post_softmax_attn, intermediates.attn_intermediates))
return out, attn_maps
return out
| EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/x_transformer.py |
import torch
from torch import nn
class LitEma(nn.Module):
def __init__(self, model, decay=0.9999, use_num_upates=True):
super().__init__()
if decay < 0.0 or decay > 1.0:
raise ValueError('Decay must be between 0 and 1')
self.m_name2s_name = {}
self.register_buffer('decay', torch.tensor(decay, dtype=torch.float32))
self.register_buffer('num_updates', torch.tensor(0,dtype=torch.int) if use_num_upates
else torch.tensor(-1,dtype=torch.int))
for name, p in model.named_parameters():
if p.requires_grad:
#remove as '.'-character is not allowed in buffers
s_name = name.replace('.','')
self.m_name2s_name.update({name:s_name})
self.register_buffer(s_name,p.clone().detach().data)
self.collected_params = []
def forward(self,model):
decay = self.decay
if self.num_updates >= 0:
self.num_updates += 1
decay = min(self.decay,(1 + self.num_updates) / (10 + self.num_updates))
one_minus_decay = 1.0 - decay
with torch.no_grad():
m_param = dict(model.named_parameters())
shadow_params = dict(self.named_buffers())
for key in m_param:
if m_param[key].requires_grad:
sname = self.m_name2s_name[key]
shadow_params[sname] = shadow_params[sname].type_as(m_param[key])
shadow_params[sname].sub_(one_minus_decay * (shadow_params[sname] - m_param[key]))
else:
assert not key in self.m_name2s_name
def copy_to(self, model):
m_param = dict(model.named_parameters())
shadow_params = dict(self.named_buffers())
for key in m_param:
if m_param[key].requires_grad:
m_param[key].data.copy_(shadow_params[self.m_name2s_name[key]].data)
else:
assert not key in self.m_name2s_name
def store(self, parameters):
"""
Save the current parameters for restoring later.
Args:
parameters: Iterable of `torch.nn.Parameter`; the parameters to be
temporarily stored.
"""
self.collected_params = [param.clone() for param in parameters]
def restore(self, parameters):
"""
Restore the parameters stored with the `store` method.
Useful to validate the model with EMA parameters without affecting the
original optimization process. Store the parameters before the
`copy_to` method. After validation (or model saving), use this to
restore the former parameters.
Args:
parameters: Iterable of `torch.nn.Parameter`; the parameters to be
updated with the stored parameters.
"""
for c_param, param in zip(self.collected_params, parameters):
param.data.copy_(c_param.data)
| EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/ema.py |
from ldm.modules.losses.contperceptual import LPIPSWithDiscriminator | EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/losses/__init__.py |
import torch
from torch import nn
import torch.nn.functional as F
from einops import repeat
from taming.modules.discriminator.model import NLayerDiscriminator, weights_init
from taming.modules.losses.lpips import LPIPS
from taming.modules.losses.vqperceptual import hinge_d_loss, vanilla_d_loss
def hinge_d_loss_with_exemplar_weights(logits_real, logits_fake, weights):
assert weights.shape[0] == logits_real.shape[0] == logits_fake.shape[0]
loss_real = torch.mean(F.relu(1. - logits_real), dim=[1,2,3])
loss_fake = torch.mean(F.relu(1. + logits_fake), dim=[1,2,3])
loss_real = (weights * loss_real).sum() / weights.sum()
loss_fake = (weights * loss_fake).sum() / weights.sum()
d_loss = 0.5 * (loss_real + loss_fake)
return d_loss
def adopt_weight(weight, global_step, threshold=0, value=0.):
if global_step < threshold:
weight = value
return weight
def measure_perplexity(predicted_indices, n_embed):
# src: https://github.com/karpathy/deep-vector-quantization/blob/main/model.py
# eval cluster perplexity. when perplexity == num_embeddings then all clusters are used exactly equally
encodings = F.one_hot(predicted_indices, n_embed).float().reshape(-1, n_embed)
avg_probs = encodings.mean(0)
perplexity = (-(avg_probs * torch.log(avg_probs + 1e-10)).sum()).exp()
cluster_use = torch.sum(avg_probs > 0)
return perplexity, cluster_use
def l1(x, y):
return torch.abs(x-y)
def l2(x, y):
return torch.pow((x-y), 2)
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", n_classes=None, perceptual_loss="lpips",
pixel_loss="l1"):
super().__init__()
assert disc_loss in ["hinge", "vanilla"]
assert perceptual_loss in ["lpips", "clips", "dists"]
assert pixel_loss in ["l1", "l2"]
self.codebook_weight = codebook_weight
self.pixel_weight = pixelloss_weight
if perceptual_loss == "lpips":
print(f"{self.__class__.__name__}: Running with LPIPS.")
self.perceptual_loss = LPIPS().eval()
else:
raise ValueError(f"Unknown perceptual loss: >> {perceptual_loss} <<")
self.perceptual_weight = perceptual_weight
if pixel_loss == "l1":
self.pixel_loss = l1
else:
self.pixel_loss = l2
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
self.n_classes = n_classes
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", predicted_indices=None):
if not exists(codebook_loss):
codebook_loss = torch.tensor([0.]).to(inputs.device)
#rec_loss = torch.abs(inputs.contiguous() - reconstructions.contiguous())
rec_loss = self.pixel_loss(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(),
}
if predicted_indices is not None:
assert self.n_classes is not None
with torch.no_grad():
perplexity, cluster_usage = measure_perplexity(predicted_indices, self.n_classes)
log[f"{split}/perplexity"] = perplexity
log[f"{split}/cluster_usage"] = cluster_usage
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
| EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/losses/vqperceptual.py |
import torch
import torch.nn as nn
from taming.modules.losses.vqperceptual import * # TODO: taming dependency yes/no?
class LPIPSWithDiscriminator(nn.Module):
def __init__(self, disc_start, logvar_init=0.0, kl_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_loss="hinge"):
super().__init__()
assert disc_loss in ["hinge", "vanilla"]
self.kl_weight = kl_weight
self.pixel_weight = pixelloss_weight
self.perceptual_loss = LPIPS().eval()
self.perceptual_weight = perceptual_weight
# output log variance
self.logvar = nn.Parameter(torch.ones(size=()) * logvar_init)
self.discriminator = NLayerDiscriminator(input_nc=disc_in_channels,
n_layers=disc_num_layers,
use_actnorm=use_actnorm
).apply(weights_init)
self.discriminator_iter_start = disc_start
self.disc_loss = hinge_d_loss if disc_loss == "hinge" else vanilla_d_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, inputs, reconstructions, posteriors, optimizer_idx,
global_step, last_layer=None, cond=None, split="train",
weights=None):
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
nll_loss = rec_loss / torch.exp(self.logvar) + self.logvar
weighted_nll_loss = nll_loss
if weights is not None:
weighted_nll_loss = weights*nll_loss
weighted_nll_loss = torch.sum(weighted_nll_loss) / weighted_nll_loss.shape[0]
nll_loss = torch.sum(nll_loss) / nll_loss.shape[0]
kl_loss = posteriors.kl()
kl_loss = torch.sum(kl_loss) / kl_loss.shape[0]
# 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)
if self.disc_factor > 0.0:
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)
else:
d_weight = torch.tensor(0.0)
disc_factor = adopt_weight(self.disc_factor, global_step, threshold=self.discriminator_iter_start)
loss = weighted_nll_loss + self.kl_weight * kl_loss + d_weight * disc_factor * g_loss
log = {"{}/total_loss".format(split): loss.clone().detach().mean(), "{}/logvar".format(split): self.logvar.detach(),
"{}/kl_loss".format(split): kl_loss.detach().mean(), "{}/nll_loss".format(split): nll_loss.detach().mean(),
"{}/rec_loss".format(split): rec_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
| EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/losses/contperceptual.py |
EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/encoders/__init__.py |
|
import torch
import torch.nn as nn
from functools import partial
import clip
from einops import rearrange, repeat
import kornia
from ldm.modules.x_transformer import Encoder, TransformerWrapper # TODO: can we directly rely on lucidrains code and simply add this as a reuirement? --> test
class AbstractEncoder(nn.Module):
def __init__(self):
super().__init__()
def encode(self, *args, **kwargs):
raise NotImplementedError
class ClassEmbedder(nn.Module):
def __init__(self, embed_dim, n_classes=1000, key='class'):
super().__init__()
self.key = key
self.embedding = nn.Embedding(n_classes, embed_dim)
def forward(self, batch, key=None):
if key is None:
key = self.key
# this is for use in crossattn
c = batch[key][:, None]
c = self.embedding(c)
return c
class TransformerEmbedder(AbstractEncoder):
"""Some transformer encoder layers"""
def __init__(self, n_embed, n_layer, vocab_size, max_seq_len=77, device="cuda"):
super().__init__()
self.device = device
self.transformer = TransformerWrapper(num_tokens=vocab_size, max_seq_len=max_seq_len,
attn_layers=Encoder(dim=n_embed, depth=n_layer))
def forward(self, tokens):
tokens = tokens.to(self.device) # meh
z = self.transformer(tokens, return_embeddings=True)
return z
def encode(self, x):
return self(x)
class BERTTokenizer(AbstractEncoder):
""" Uses a pretrained BERT tokenizer by huggingface. Vocab size: 30522 (?)"""
def __init__(self, device="cuda", vq_interface=True, max_length=77):
super().__init__()
from transformers import BertTokenizerFast # TODO: add to reuquirements
self.tokenizer = BertTokenizerFast.from_pretrained("bert-base-uncased")
self.device = device
self.vq_interface = vq_interface
self.max_length = max_length
def forward(self, text):
batch_encoding = self.tokenizer(text, truncation=True, max_length=self.max_length, return_length=True,
return_overflowing_tokens=False, padding="max_length", return_tensors="pt")
tokens = batch_encoding["input_ids"].to(self.device)
return tokens
@torch.no_grad()
def encode(self, text):
tokens = self(text)
if not self.vq_interface:
return tokens
return None, None, [None, None, tokens]
def decode(self, text):
return text
class BERTEmbedder(AbstractEncoder):
"""Uses the BERT tokenizr model and add some transformer encoder layers"""
def __init__(self, n_embed, n_layer, vocab_size=30522, max_seq_len=77,
device="cuda",use_tokenizer=True, embedding_dropout=0.0):
super().__init__()
self.use_tknz_fn = use_tokenizer
if self.use_tknz_fn:
self.tknz_fn = BERTTokenizer(vq_interface=False, max_length=max_seq_len)
self.device = device
self.transformer = TransformerWrapper(num_tokens=vocab_size, max_seq_len=max_seq_len,
attn_layers=Encoder(dim=n_embed, depth=n_layer),
emb_dropout=embedding_dropout)
def forward(self, text):
if self.use_tknz_fn:
tokens = self.tknz_fn(text)#.to(self.device)
else:
tokens = text
z = self.transformer(tokens, return_embeddings=True)
return z
def encode(self, text):
# output of length 77
return self(text)
class SpatialRescaler(nn.Module):
def __init__(self,
n_stages=1,
method='bilinear',
multiplier=0.5,
in_channels=3,
out_channels=None,
bias=False):
super().__init__()
self.n_stages = n_stages
assert self.n_stages >= 0
assert method in ['nearest','linear','bilinear','trilinear','bicubic','area']
self.multiplier = multiplier
self.interpolator = partial(torch.nn.functional.interpolate, mode=method)
self.remap_output = out_channels is not None
if self.remap_output:
print(f'Spatial Rescaler mapping from {in_channels} to {out_channels} channels after resizing.')
self.channel_mapper = nn.Conv2d(in_channels,out_channels,1,bias=bias)
def forward(self,x):
for stage in range(self.n_stages):
x = self.interpolator(x, scale_factor=self.multiplier)
if self.remap_output:
x = self.channel_mapper(x)
return x
def encode(self, x):
return self(x)
class FrozenCLIPTextEmbedder(nn.Module):
"""
Uses the CLIP transformer encoder for text.
"""
def __init__(self, version='ViT-L/14', device="cuda", max_length=77, n_repeat=1, normalize=True):
super().__init__()
self.model, _ = clip.load(version, jit=False, device="cpu")
self.device = device
self.max_length = max_length
self.n_repeat = n_repeat
self.normalize = normalize
def freeze(self):
self.model = self.model.eval()
for param in self.parameters():
param.requires_grad = False
def forward(self, text):
tokens = clip.tokenize(text).to(self.device)
z = self.model.encode_text(tokens)
if self.normalize:
z = z / torch.linalg.norm(z, dim=1, keepdim=True)
return z
def encode(self, text):
z = self(text)
if z.ndim==2:
z = z[:, None, :]
z = repeat(z, 'b 1 d -> b k d', k=self.n_repeat)
return z
class FrozenClipImageEmbedder(nn.Module):
"""
Uses the CLIP image encoder.
"""
def __init__(
self,
model,
jit=False,
device='cuda' if torch.cuda.is_available() else 'cpu',
antialias=False,
):
super().__init__()
self.model, _ = clip.load(name=model, device=device, jit=jit)
self.antialias = antialias
self.register_buffer('mean', torch.Tensor([0.48145466, 0.4578275, 0.40821073]), persistent=False)
self.register_buffer('std', torch.Tensor([0.26862954, 0.26130258, 0.27577711]), persistent=False)
def preprocess(self, x):
# normalize to [0,1]
x = kornia.geometry.resize(x, (224, 224),
interpolation='bicubic',align_corners=True,
antialias=self.antialias)
x = (x + 1.) / 2.
# renormalize according to clip
x = kornia.enhance.normalize(x, self.mean, self.std)
return x
def forward(self, x):
# x is assumed to be in range [-1,1]
return self.model.encode_image(self.preprocess(x))
| EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/encoders/modules.py |
# -*- coding: utf-8 -*-
"""
# --------------------------------------------
# Super-Resolution
# --------------------------------------------
#
# Kai Zhang ([email protected])
# https://github.com/cszn
# From 2019/03--2021/08
# --------------------------------------------
"""
import numpy as np
import cv2
import torch
from functools import partial
import random
from scipy import ndimage
import scipy
import scipy.stats as ss
from scipy.interpolate import interp2d
from scipy.linalg import orth
import albumentations
import ldm.modules.image_degradation.utils_image as util
def modcrop_np(img, sf):
'''
Args:
img: numpy image, WxH or WxHxC
sf: scale factor
Return:
cropped image
'''
w, h = img.shape[:2]
im = np.copy(img)
return im[:w - w % sf, :h - h % sf, ...]
"""
# --------------------------------------------
# anisotropic Gaussian kernels
# --------------------------------------------
"""
def analytic_kernel(k):
"""Calculate the X4 kernel from the X2 kernel (for proof see appendix in paper)"""
k_size = k.shape[0]
# Calculate the big kernels size
big_k = np.zeros((3 * k_size - 2, 3 * k_size - 2))
# Loop over the small kernel to fill the big one
for r in range(k_size):
for c in range(k_size):
big_k[2 * r:2 * r + k_size, 2 * c:2 * c + k_size] += k[r, c] * k
# Crop the edges of the big kernel to ignore very small values and increase run time of SR
crop = k_size // 2
cropped_big_k = big_k[crop:-crop, crop:-crop]
# Normalize to 1
return cropped_big_k / cropped_big_k.sum()
def anisotropic_Gaussian(ksize=15, theta=np.pi, l1=6, l2=6):
""" generate an anisotropic Gaussian kernel
Args:
ksize : e.g., 15, kernel size
theta : [0, pi], rotation angle range
l1 : [0.1,50], scaling of eigenvalues
l2 : [0.1,l1], scaling of eigenvalues
If l1 = l2, will get an isotropic Gaussian kernel.
Returns:
k : kernel
"""
v = np.dot(np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]), np.array([1., 0.]))
V = np.array([[v[0], v[1]], [v[1], -v[0]]])
D = np.array([[l1, 0], [0, l2]])
Sigma = np.dot(np.dot(V, D), np.linalg.inv(V))
k = gm_blur_kernel(mean=[0, 0], cov=Sigma, size=ksize)
return k
def gm_blur_kernel(mean, cov, size=15):
center = size / 2.0 + 0.5
k = np.zeros([size, size])
for y in range(size):
for x in range(size):
cy = y - center + 1
cx = x - center + 1
k[y, x] = ss.multivariate_normal.pdf([cx, cy], mean=mean, cov=cov)
k = k / np.sum(k)
return k
def shift_pixel(x, sf, upper_left=True):
"""shift pixel for super-resolution with different scale factors
Args:
x: WxHxC or WxH
sf: scale factor
upper_left: shift direction
"""
h, w = x.shape[:2]
shift = (sf - 1) * 0.5
xv, yv = np.arange(0, w, 1.0), np.arange(0, h, 1.0)
if upper_left:
x1 = xv + shift
y1 = yv + shift
else:
x1 = xv - shift
y1 = yv - shift
x1 = np.clip(x1, 0, w - 1)
y1 = np.clip(y1, 0, h - 1)
if x.ndim == 2:
x = interp2d(xv, yv, x)(x1, y1)
if x.ndim == 3:
for i in range(x.shape[-1]):
x[:, :, i] = interp2d(xv, yv, x[:, :, i])(x1, y1)
return x
def blur(x, k):
'''
x: image, NxcxHxW
k: kernel, Nx1xhxw
'''
n, c = x.shape[:2]
p1, p2 = (k.shape[-2] - 1) // 2, (k.shape[-1] - 1) // 2
x = torch.nn.functional.pad(x, pad=(p1, p2, p1, p2), mode='replicate')
k = k.repeat(1, c, 1, 1)
k = k.view(-1, 1, k.shape[2], k.shape[3])
x = x.view(1, -1, x.shape[2], x.shape[3])
x = torch.nn.functional.conv2d(x, k, bias=None, stride=1, padding=0, groups=n * c)
x = x.view(n, c, x.shape[2], x.shape[3])
return x
def gen_kernel(k_size=np.array([15, 15]), scale_factor=np.array([4, 4]), min_var=0.6, max_var=10., noise_level=0):
""""
# modified version of https://github.com/assafshocher/BlindSR_dataset_generator
# Kai Zhang
# min_var = 0.175 * sf # variance of the gaussian kernel will be sampled between min_var and max_var
# max_var = 2.5 * sf
"""
# Set random eigen-vals (lambdas) and angle (theta) for COV matrix
lambda_1 = min_var + np.random.rand() * (max_var - min_var)
lambda_2 = min_var + np.random.rand() * (max_var - min_var)
theta = np.random.rand() * np.pi # random theta
noise = -noise_level + np.random.rand(*k_size) * noise_level * 2
# Set COV matrix using Lambdas and Theta
LAMBDA = np.diag([lambda_1, lambda_2])
Q = np.array([[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)]])
SIGMA = Q @ LAMBDA @ Q.T
INV_SIGMA = np.linalg.inv(SIGMA)[None, None, :, :]
# Set expectation position (shifting kernel for aligned image)
MU = k_size // 2 - 0.5 * (scale_factor - 1) # - 0.5 * (scale_factor - k_size % 2)
MU = MU[None, None, :, None]
# Create meshgrid for Gaussian
[X, Y] = np.meshgrid(range(k_size[0]), range(k_size[1]))
Z = np.stack([X, Y], 2)[:, :, :, None]
# Calcualte Gaussian for every pixel of the kernel
ZZ = Z - MU
ZZ_t = ZZ.transpose(0, 1, 3, 2)
raw_kernel = np.exp(-0.5 * np.squeeze(ZZ_t @ INV_SIGMA @ ZZ)) * (1 + noise)
# shift the kernel so it will be centered
# raw_kernel_centered = kernel_shift(raw_kernel, scale_factor)
# Normalize the kernel and return
# kernel = raw_kernel_centered / np.sum(raw_kernel_centered)
kernel = raw_kernel / np.sum(raw_kernel)
return kernel
def fspecial_gaussian(hsize, sigma):
hsize = [hsize, hsize]
siz = [(hsize[0] - 1.0) / 2.0, (hsize[1] - 1.0) / 2.0]
std = sigma
[x, y] = np.meshgrid(np.arange(-siz[1], siz[1] + 1), np.arange(-siz[0], siz[0] + 1))
arg = -(x * x + y * y) / (2 * std * std)
h = np.exp(arg)
h[h < scipy.finfo(float).eps * h.max()] = 0
sumh = h.sum()
if sumh != 0:
h = h / sumh
return h
def fspecial_laplacian(alpha):
alpha = max([0, min([alpha, 1])])
h1 = alpha / (alpha + 1)
h2 = (1 - alpha) / (alpha + 1)
h = [[h1, h2, h1], [h2, -4 / (alpha + 1), h2], [h1, h2, h1]]
h = np.array(h)
return h
def fspecial(filter_type, *args, **kwargs):
'''
python code from:
https://github.com/ronaldosena/imagens-medicas-2/blob/40171a6c259edec7827a6693a93955de2bd39e76/Aulas/aula_2_-_uniform_filter/matlab_fspecial.py
'''
if filter_type == 'gaussian':
return fspecial_gaussian(*args, **kwargs)
if filter_type == 'laplacian':
return fspecial_laplacian(*args, **kwargs)
"""
# --------------------------------------------
# degradation models
# --------------------------------------------
"""
def bicubic_degradation(x, sf=3):
'''
Args:
x: HxWxC image, [0, 1]
sf: down-scale factor
Return:
bicubicly downsampled LR image
'''
x = util.imresize_np(x, scale=1 / sf)
return x
def srmd_degradation(x, k, sf=3):
''' blur + bicubic downsampling
Args:
x: HxWxC image, [0, 1]
k: hxw, double
sf: down-scale factor
Return:
downsampled LR image
Reference:
@inproceedings{zhang2018learning,
title={Learning a single convolutional super-resolution network for multiple degradations},
author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei},
booktitle={IEEE Conference on Computer Vision and Pattern Recognition},
pages={3262--3271},
year={2018}
}
'''
x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap') # 'nearest' | 'mirror'
x = bicubic_degradation(x, sf=sf)
return x
def dpsr_degradation(x, k, sf=3):
''' bicubic downsampling + blur
Args:
x: HxWxC image, [0, 1]
k: hxw, double
sf: down-scale factor
Return:
downsampled LR image
Reference:
@inproceedings{zhang2019deep,
title={Deep Plug-and-Play Super-Resolution for Arbitrary Blur Kernels},
author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei},
booktitle={IEEE Conference on Computer Vision and Pattern Recognition},
pages={1671--1681},
year={2019}
}
'''
x = bicubic_degradation(x, sf=sf)
x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap')
return x
def classical_degradation(x, k, sf=3):
''' blur + downsampling
Args:
x: HxWxC image, [0, 1]/[0, 255]
k: hxw, double
sf: down-scale factor
Return:
downsampled LR image
'''
x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap')
# x = filters.correlate(x, np.expand_dims(np.flip(k), axis=2))
st = 0
return x[st::sf, st::sf, ...]
def add_sharpening(img, weight=0.5, radius=50, threshold=10):
"""USM sharpening. borrowed from real-ESRGAN
Input image: I; Blurry image: B.
1. K = I + weight * (I - B)
2. Mask = 1 if abs(I - B) > threshold, else: 0
3. Blur mask:
4. Out = Mask * K + (1 - Mask) * I
Args:
img (Numpy array): Input image, HWC, BGR; float32, [0, 1].
weight (float): Sharp weight. Default: 1.
radius (float): Kernel size of Gaussian blur. Default: 50.
threshold (int):
"""
if radius % 2 == 0:
radius += 1
blur = cv2.GaussianBlur(img, (radius, radius), 0)
residual = img - blur
mask = np.abs(residual) * 255 > threshold
mask = mask.astype('float32')
soft_mask = cv2.GaussianBlur(mask, (radius, radius), 0)
K = img + weight * residual
K = np.clip(K, 0, 1)
return soft_mask * K + (1 - soft_mask) * img
def add_blur(img, sf=4):
wd2 = 4.0 + sf
wd = 2.0 + 0.2 * sf
if random.random() < 0.5:
l1 = wd2 * random.random()
l2 = wd2 * random.random()
k = anisotropic_Gaussian(ksize=2 * random.randint(2, 11) + 3, theta=random.random() * np.pi, l1=l1, l2=l2)
else:
k = fspecial('gaussian', 2 * random.randint(2, 11) + 3, wd * random.random())
img = ndimage.filters.convolve(img, np.expand_dims(k, axis=2), mode='mirror')
return img
def add_resize(img, sf=4):
rnum = np.random.rand()
if rnum > 0.8: # up
sf1 = random.uniform(1, 2)
elif rnum < 0.7: # down
sf1 = random.uniform(0.5 / sf, 1)
else:
sf1 = 1.0
img = cv2.resize(img, (int(sf1 * img.shape[1]), int(sf1 * img.shape[0])), interpolation=random.choice([1, 2, 3]))
img = np.clip(img, 0.0, 1.0)
return img
# def add_Gaussian_noise(img, noise_level1=2, noise_level2=25):
# noise_level = random.randint(noise_level1, noise_level2)
# rnum = np.random.rand()
# if rnum > 0.6: # add color Gaussian noise
# img += np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32)
# elif rnum < 0.4: # add grayscale Gaussian noise
# img += np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32)
# else: # add noise
# L = noise_level2 / 255.
# D = np.diag(np.random.rand(3))
# U = orth(np.random.rand(3, 3))
# conv = np.dot(np.dot(np.transpose(U), D), U)
# img += np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
# img = np.clip(img, 0.0, 1.0)
# return img
def add_Gaussian_noise(img, noise_level1=2, noise_level2=25):
noise_level = random.randint(noise_level1, noise_level2)
rnum = np.random.rand()
if rnum > 0.6: # add color Gaussian noise
img = img + np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32)
elif rnum < 0.4: # add grayscale Gaussian noise
img = img + np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32)
else: # add noise
L = noise_level2 / 255.
D = np.diag(np.random.rand(3))
U = orth(np.random.rand(3, 3))
conv = np.dot(np.dot(np.transpose(U), D), U)
img = img + np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
img = np.clip(img, 0.0, 1.0)
return img
def add_speckle_noise(img, noise_level1=2, noise_level2=25):
noise_level = random.randint(noise_level1, noise_level2)
img = np.clip(img, 0.0, 1.0)
rnum = random.random()
if rnum > 0.6:
img += img * np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32)
elif rnum < 0.4:
img += img * np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32)
else:
L = noise_level2 / 255.
D = np.diag(np.random.rand(3))
U = orth(np.random.rand(3, 3))
conv = np.dot(np.dot(np.transpose(U), D), U)
img += img * np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
img = np.clip(img, 0.0, 1.0)
return img
def add_Poisson_noise(img):
img = np.clip((img * 255.0).round(), 0, 255) / 255.
vals = 10 ** (2 * random.random() + 2.0) # [2, 4]
if random.random() < 0.5:
img = np.random.poisson(img * vals).astype(np.float32) / vals
else:
img_gray = np.dot(img[..., :3], [0.299, 0.587, 0.114])
img_gray = np.clip((img_gray * 255.0).round(), 0, 255) / 255.
noise_gray = np.random.poisson(img_gray * vals).astype(np.float32) / vals - img_gray
img += noise_gray[:, :, np.newaxis]
img = np.clip(img, 0.0, 1.0)
return img
def add_JPEG_noise(img):
quality_factor = random.randint(30, 95)
img = cv2.cvtColor(util.single2uint(img), cv2.COLOR_RGB2BGR)
result, encimg = cv2.imencode('.jpg', img, [int(cv2.IMWRITE_JPEG_QUALITY), quality_factor])
img = cv2.imdecode(encimg, 1)
img = cv2.cvtColor(util.uint2single(img), cv2.COLOR_BGR2RGB)
return img
def random_crop(lq, hq, sf=4, lq_patchsize=64):
h, w = lq.shape[:2]
rnd_h = random.randint(0, h - lq_patchsize)
rnd_w = random.randint(0, w - lq_patchsize)
lq = lq[rnd_h:rnd_h + lq_patchsize, rnd_w:rnd_w + lq_patchsize, :]
rnd_h_H, rnd_w_H = int(rnd_h * sf), int(rnd_w * sf)
hq = hq[rnd_h_H:rnd_h_H + lq_patchsize * sf, rnd_w_H:rnd_w_H + lq_patchsize * sf, :]
return lq, hq
def degradation_bsrgan(img, sf=4, lq_patchsize=72, isp_model=None):
"""
This is the degradation model of BSRGAN from the paper
"Designing a Practical Degradation Model for Deep Blind Image Super-Resolution"
----------
img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf)
sf: scale factor
isp_model: camera ISP model
Returns
-------
img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1]
hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1]
"""
isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25
sf_ori = sf
h1, w1 = img.shape[:2]
img = img.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop
h, w = img.shape[:2]
if h < lq_patchsize * sf or w < lq_patchsize * sf:
raise ValueError(f'img size ({h1}X{w1}) is too small!')
hq = img.copy()
if sf == 4 and random.random() < scale2_prob: # downsample1
if np.random.rand() < 0.5:
img = cv2.resize(img, (int(1 / 2 * img.shape[1]), int(1 / 2 * img.shape[0])),
interpolation=random.choice([1, 2, 3]))
else:
img = util.imresize_np(img, 1 / 2, True)
img = np.clip(img, 0.0, 1.0)
sf = 2
shuffle_order = random.sample(range(7), 7)
idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3)
if idx1 > idx2: # keep downsample3 last
shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1]
for i in shuffle_order:
if i == 0:
img = add_blur(img, sf=sf)
elif i == 1:
img = add_blur(img, sf=sf)
elif i == 2:
a, b = img.shape[1], img.shape[0]
# downsample2
if random.random() < 0.75:
sf1 = random.uniform(1, 2 * sf)
img = cv2.resize(img, (int(1 / sf1 * img.shape[1]), int(1 / sf1 * img.shape[0])),
interpolation=random.choice([1, 2, 3]))
else:
k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf))
k_shifted = shift_pixel(k, sf)
k_shifted = k_shifted / k_shifted.sum() # blur with shifted kernel
img = ndimage.filters.convolve(img, np.expand_dims(k_shifted, axis=2), mode='mirror')
img = img[0::sf, 0::sf, ...] # nearest downsampling
img = np.clip(img, 0.0, 1.0)
elif i == 3:
# downsample3
img = cv2.resize(img, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3]))
img = np.clip(img, 0.0, 1.0)
elif i == 4:
# add Gaussian noise
img = add_Gaussian_noise(img, noise_level1=2, noise_level2=25)
elif i == 5:
# add JPEG noise
if random.random() < jpeg_prob:
img = add_JPEG_noise(img)
elif i == 6:
# add processed camera sensor noise
if random.random() < isp_prob and isp_model is not None:
with torch.no_grad():
img, hq = isp_model.forward(img.copy(), hq)
# add final JPEG compression noise
img = add_JPEG_noise(img)
# random crop
img, hq = random_crop(img, hq, sf_ori, lq_patchsize)
return img, hq
# todo no isp_model?
def degradation_bsrgan_variant(image, sf=4, isp_model=None):
"""
This is the degradation model of BSRGAN from the paper
"Designing a Practical Degradation Model for Deep Blind Image Super-Resolution"
----------
sf: scale factor
isp_model: camera ISP model
Returns
-------
img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1]
hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1]
"""
image = util.uint2single(image)
isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25
sf_ori = sf
h1, w1 = image.shape[:2]
image = image.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop
h, w = image.shape[:2]
hq = image.copy()
if sf == 4 and random.random() < scale2_prob: # downsample1
if np.random.rand() < 0.5:
image = cv2.resize(image, (int(1 / 2 * image.shape[1]), int(1 / 2 * image.shape[0])),
interpolation=random.choice([1, 2, 3]))
else:
image = util.imresize_np(image, 1 / 2, True)
image = np.clip(image, 0.0, 1.0)
sf = 2
shuffle_order = random.sample(range(7), 7)
idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3)
if idx1 > idx2: # keep downsample3 last
shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1]
for i in shuffle_order:
if i == 0:
image = add_blur(image, sf=sf)
elif i == 1:
image = add_blur(image, sf=sf)
elif i == 2:
a, b = image.shape[1], image.shape[0]
# downsample2
if random.random() < 0.75:
sf1 = random.uniform(1, 2 * sf)
image = cv2.resize(image, (int(1 / sf1 * image.shape[1]), int(1 / sf1 * image.shape[0])),
interpolation=random.choice([1, 2, 3]))
else:
k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf))
k_shifted = shift_pixel(k, sf)
k_shifted = k_shifted / k_shifted.sum() # blur with shifted kernel
image = ndimage.filters.convolve(image, np.expand_dims(k_shifted, axis=2), mode='mirror')
image = image[0::sf, 0::sf, ...] # nearest downsampling
image = np.clip(image, 0.0, 1.0)
elif i == 3:
# downsample3
image = cv2.resize(image, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3]))
image = np.clip(image, 0.0, 1.0)
elif i == 4:
# add Gaussian noise
image = add_Gaussian_noise(image, noise_level1=2, noise_level2=25)
elif i == 5:
# add JPEG noise
if random.random() < jpeg_prob:
image = add_JPEG_noise(image)
# elif i == 6:
# # add processed camera sensor noise
# if random.random() < isp_prob and isp_model is not None:
# with torch.no_grad():
# img, hq = isp_model.forward(img.copy(), hq)
# add final JPEG compression noise
image = add_JPEG_noise(image)
image = util.single2uint(image)
example = {"image":image}
return example
# TODO incase there is a pickle error one needs to replace a += x with a = a + x in add_speckle_noise etc...
def degradation_bsrgan_plus(img, sf=4, shuffle_prob=0.5, use_sharp=True, lq_patchsize=64, isp_model=None):
"""
This is an extended degradation model by combining
the degradation models of BSRGAN and Real-ESRGAN
----------
img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf)
sf: scale factor
use_shuffle: the degradation shuffle
use_sharp: sharpening the img
Returns
-------
img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1]
hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1]
"""
h1, w1 = img.shape[:2]
img = img.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop
h, w = img.shape[:2]
if h < lq_patchsize * sf or w < lq_patchsize * sf:
raise ValueError(f'img size ({h1}X{w1}) is too small!')
if use_sharp:
img = add_sharpening(img)
hq = img.copy()
if random.random() < shuffle_prob:
shuffle_order = random.sample(range(13), 13)
else:
shuffle_order = list(range(13))
# local shuffle for noise, JPEG is always the last one
shuffle_order[2:6] = random.sample(shuffle_order[2:6], len(range(2, 6)))
shuffle_order[9:13] = random.sample(shuffle_order[9:13], len(range(9, 13)))
poisson_prob, speckle_prob, isp_prob = 0.1, 0.1, 0.1
for i in shuffle_order:
if i == 0:
img = add_blur(img, sf=sf)
elif i == 1:
img = add_resize(img, sf=sf)
elif i == 2:
img = add_Gaussian_noise(img, noise_level1=2, noise_level2=25)
elif i == 3:
if random.random() < poisson_prob:
img = add_Poisson_noise(img)
elif i == 4:
if random.random() < speckle_prob:
img = add_speckle_noise(img)
elif i == 5:
if random.random() < isp_prob and isp_model is not None:
with torch.no_grad():
img, hq = isp_model.forward(img.copy(), hq)
elif i == 6:
img = add_JPEG_noise(img)
elif i == 7:
img = add_blur(img, sf=sf)
elif i == 8:
img = add_resize(img, sf=sf)
elif i == 9:
img = add_Gaussian_noise(img, noise_level1=2, noise_level2=25)
elif i == 10:
if random.random() < poisson_prob:
img = add_Poisson_noise(img)
elif i == 11:
if random.random() < speckle_prob:
img = add_speckle_noise(img)
elif i == 12:
if random.random() < isp_prob and isp_model is not None:
with torch.no_grad():
img, hq = isp_model.forward(img.copy(), hq)
else:
print('check the shuffle!')
# resize to desired size
img = cv2.resize(img, (int(1 / sf * hq.shape[1]), int(1 / sf * hq.shape[0])),
interpolation=random.choice([1, 2, 3]))
# add final JPEG compression noise
img = add_JPEG_noise(img)
# random crop
img, hq = random_crop(img, hq, sf, lq_patchsize)
return img, hq
if __name__ == '__main__':
print("hey")
img = util.imread_uint('utils/test.png', 3)
print(img)
img = util.uint2single(img)
print(img)
img = img[:448, :448]
h = img.shape[0] // 4
print("resizing to", h)
sf = 4
deg_fn = partial(degradation_bsrgan_variant, sf=sf)
for i in range(20):
print(i)
img_lq = deg_fn(img)
print(img_lq)
img_lq_bicubic = albumentations.SmallestMaxSize(max_size=h, interpolation=cv2.INTER_CUBIC)(image=img)["image"]
print(img_lq.shape)
print("bicubic", img_lq_bicubic.shape)
print(img_hq.shape)
lq_nearest = cv2.resize(util.single2uint(img_lq), (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])),
interpolation=0)
lq_bicubic_nearest = cv2.resize(util.single2uint(img_lq_bicubic), (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])),
interpolation=0)
img_concat = np.concatenate([lq_bicubic_nearest, lq_nearest, util.single2uint(img_hq)], axis=1)
util.imsave(img_concat, str(i) + '.png')
| EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/image_degradation/bsrgan.py |
from ldm.modules.image_degradation.bsrgan import degradation_bsrgan_variant as degradation_fn_bsr
from ldm.modules.image_degradation.bsrgan_light import degradation_bsrgan_variant as degradation_fn_bsr_light
| EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/image_degradation/__init__.py |
import os
import math
import random
import numpy as np
import torch
import cv2
from torchvision.utils import make_grid
from datetime import datetime
#import matplotlib.pyplot as plt # TODO: check with Dominik, also bsrgan.py vs bsrgan_light.py
os.environ["KMP_DUPLICATE_LIB_OK"]="TRUE"
'''
# --------------------------------------------
# Kai Zhang (github: https://github.com/cszn)
# 03/Mar/2019
# --------------------------------------------
# https://github.com/twhui/SRGAN-pyTorch
# https://github.com/xinntao/BasicSR
# --------------------------------------------
'''
IMG_EXTENSIONS = ['.jpg', '.JPG', '.jpeg', '.JPEG', '.png', '.PNG', '.ppm', '.PPM', '.bmp', '.BMP', '.tif']
def is_image_file(filename):
return any(filename.endswith(extension) for extension in IMG_EXTENSIONS)
def get_timestamp():
return datetime.now().strftime('%y%m%d-%H%M%S')
def imshow(x, title=None, cbar=False, figsize=None):
plt.figure(figsize=figsize)
plt.imshow(np.squeeze(x), interpolation='nearest', cmap='gray')
if title:
plt.title(title)
if cbar:
plt.colorbar()
plt.show()
def surf(Z, cmap='rainbow', figsize=None):
plt.figure(figsize=figsize)
ax3 = plt.axes(projection='3d')
w, h = Z.shape[:2]
xx = np.arange(0,w,1)
yy = np.arange(0,h,1)
X, Y = np.meshgrid(xx, yy)
ax3.plot_surface(X,Y,Z,cmap=cmap)
#ax3.contour(X,Y,Z, zdim='z',offset=-2，cmap=cmap)
plt.show()
'''
# --------------------------------------------
# get image pathes
# --------------------------------------------
'''
def get_image_paths(dataroot):
paths = None # return None if dataroot is None
if dataroot is not None:
paths = sorted(_get_paths_from_images(dataroot))
return paths
def _get_paths_from_images(path):
assert os.path.isdir(path), '{:s} is not a valid directory'.format(path)
images = []
for dirpath, _, fnames in sorted(os.walk(path)):
for fname in sorted(fnames):
if is_image_file(fname):
img_path = os.path.join(dirpath, fname)
images.append(img_path)
assert images, '{:s} has no valid image file'.format(path)
return images
'''
# --------------------------------------------
# split large images into small images
# --------------------------------------------
'''
def patches_from_image(img, p_size=512, p_overlap=64, p_max=800):
w, h = img.shape[:2]
patches = []
if w > p_max and h > p_max:
w1 = list(np.arange(0, w-p_size, p_size-p_overlap, dtype=np.int))
h1 = list(np.arange(0, h-p_size, p_size-p_overlap, dtype=np.int))
w1.append(w-p_size)
h1.append(h-p_size)
# print(w1)
# print(h1)
for i in w1:
for j in h1:
patches.append(img[i:i+p_size, j:j+p_size,:])
else:
patches.append(img)
return patches
def imssave(imgs, img_path):
"""
imgs: list, N images of size WxHxC
"""
img_name, ext = os.path.splitext(os.path.basename(img_path))
for i, img in enumerate(imgs):
if img.ndim == 3:
img = img[:, :, [2, 1, 0]]
new_path = os.path.join(os.path.dirname(img_path), img_name+str('_s{:04d}'.format(i))+'.png')
cv2.imwrite(new_path, img)
def split_imageset(original_dataroot, taget_dataroot, n_channels=3, p_size=800, p_overlap=96, p_max=1000):
"""
split the large images from original_dataroot into small overlapped images with size (p_size)x(p_size),
and save them into taget_dataroot; only the images with larger size than (p_max)x(p_max)
will be splitted.
Args:
original_dataroot:
taget_dataroot:
p_size: size of small images
p_overlap: patch size in training is a good choice
p_max: images with smaller size than (p_max)x(p_max) keep unchanged.
"""
paths = get_image_paths(original_dataroot)
for img_path in paths:
# img_name, ext = os.path.splitext(os.path.basename(img_path))
img = imread_uint(img_path, n_channels=n_channels)
patches = patches_from_image(img, p_size, p_overlap, p_max)
imssave(patches, os.path.join(taget_dataroot,os.path.basename(img_path)))
#if original_dataroot == taget_dataroot:
#del img_path
'''
# --------------------------------------------
# makedir
# --------------------------------------------
'''
def mkdir(path):
if not os.path.exists(path):
os.makedirs(path)
def mkdirs(paths):
if isinstance(paths, str):
mkdir(paths)
else:
for path in paths:
mkdir(path)
def mkdir_and_rename(path):
if os.path.exists(path):
new_name = path + '_archived_' + get_timestamp()
print('Path already exists. Rename it to [{:s}]'.format(new_name))
os.rename(path, new_name)
os.makedirs(path)
'''
# --------------------------------------------
# read image from path
# opencv is fast, but read BGR numpy image
# --------------------------------------------
'''
# --------------------------------------------
# get uint8 image of size HxWxn_channles (RGB)
# --------------------------------------------
def imread_uint(path, n_channels=3):
# input: path
# output: HxWx3(RGB or GGG), or HxWx1 (G)
if n_channels == 1:
img = cv2.imread(path, 0) # cv2.IMREAD_GRAYSCALE
img = np.expand_dims(img, axis=2) # HxWx1
elif n_channels == 3:
img = cv2.imread(path, cv2.IMREAD_UNCHANGED) # BGR or G
if img.ndim == 2:
img = cv2.cvtColor(img, cv2.COLOR_GRAY2RGB) # GGG
else:
img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB) # RGB
return img
# --------------------------------------------
# matlab's imwrite
# --------------------------------------------
def imsave(img, img_path):
img = np.squeeze(img)
if img.ndim == 3:
img = img[:, :, [2, 1, 0]]
cv2.imwrite(img_path, img)
def imwrite(img, img_path):
img = np.squeeze(img)
if img.ndim == 3:
img = img[:, :, [2, 1, 0]]
cv2.imwrite(img_path, img)
# --------------------------------------------
# get single image of size HxWxn_channles (BGR)
# --------------------------------------------
def read_img(path):
# read image by cv2
# return: Numpy float32, HWC, BGR, [0,1]
img = cv2.imread(path, cv2.IMREAD_UNCHANGED) # cv2.IMREAD_GRAYSCALE
img = img.astype(np.float32) / 255.
if img.ndim == 2:
img = np.expand_dims(img, axis=2)
# some images have 4 channels
if img.shape[2] > 3:
img = img[:, :, :3]
return img
'''
# --------------------------------------------
# image format conversion
# --------------------------------------------
# numpy(single) <---> numpy(unit)
# numpy(single) <---> tensor
# numpy(unit) <---> tensor
# --------------------------------------------
'''
# --------------------------------------------
# numpy(single) [0, 1] <---> numpy(unit)
# --------------------------------------------
def uint2single(img):
return np.float32(img/255.)
def single2uint(img):
return np.uint8((img.clip(0, 1)*255.).round())
def uint162single(img):
return np.float32(img/65535.)
def single2uint16(img):
return np.uint16((img.clip(0, 1)*65535.).round())
# --------------------------------------------
# numpy(unit) (HxWxC or HxW) <---> tensor
# --------------------------------------------
# convert uint to 4-dimensional torch tensor
def uint2tensor4(img):
if img.ndim == 2:
img = np.expand_dims(img, axis=2)
return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float().div(255.).unsqueeze(0)
# convert uint to 3-dimensional torch tensor
def uint2tensor3(img):
if img.ndim == 2:
img = np.expand_dims(img, axis=2)
return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float().div(255.)
# convert 2/3/4-dimensional torch tensor to uint
def tensor2uint(img):
img = img.data.squeeze().float().clamp_(0, 1).cpu().numpy()
if img.ndim == 3:
img = np.transpose(img, (1, 2, 0))
return np.uint8((img*255.0).round())
# --------------------------------------------
# numpy(single) (HxWxC) <---> tensor
# --------------------------------------------
# convert single (HxWxC) to 3-dimensional torch tensor
def single2tensor3(img):
return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float()
# convert single (HxWxC) to 4-dimensional torch tensor
def single2tensor4(img):
return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1).float().unsqueeze(0)
# convert torch tensor to single
def tensor2single(img):
img = img.data.squeeze().float().cpu().numpy()
if img.ndim == 3:
img = np.transpose(img, (1, 2, 0))
return img
# convert torch tensor to single
def tensor2single3(img):
img = img.data.squeeze().float().cpu().numpy()
if img.ndim == 3:
img = np.transpose(img, (1, 2, 0))
elif img.ndim == 2:
img = np.expand_dims(img, axis=2)
return img
def single2tensor5(img):
return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1, 3).float().unsqueeze(0)
def single32tensor5(img):
return torch.from_numpy(np.ascontiguousarray(img)).float().unsqueeze(0).unsqueeze(0)
def single42tensor4(img):
return torch.from_numpy(np.ascontiguousarray(img)).permute(2, 0, 1, 3).float()
# from skimage.io import imread, imsave
def tensor2img(tensor, out_type=np.uint8, min_max=(0, 1)):
'''
Converts a torch Tensor into an image Numpy array of BGR channel order
Input: 4D(B,(3/1),H,W), 3D(C,H,W), or 2D(H,W), any range, RGB channel order
Output: 3D(H,W,C) or 2D(H,W), [0,255], np.uint8 (default)
'''
tensor = tensor.squeeze().float().cpu().clamp_(*min_max) # squeeze first, then clamp
tensor = (tensor - min_max[0]) / (min_max[1] - min_max[0]) # to range [0,1]
n_dim = tensor.dim()
if n_dim == 4:
n_img = len(tensor)
img_np = make_grid(tensor, nrow=int(math.sqrt(n_img)), normalize=False).numpy()
img_np = np.transpose(img_np[[2, 1, 0], :, :], (1, 2, 0)) # HWC, BGR
elif n_dim == 3:
img_np = tensor.numpy()
img_np = np.transpose(img_np[[2, 1, 0], :, :], (1, 2, 0)) # HWC, BGR
elif n_dim == 2:
img_np = tensor.numpy()
else:
raise TypeError(
'Only support 4D, 3D and 2D tensor. But received with dimension: {:d}'.format(n_dim))
if out_type == np.uint8:
img_np = (img_np * 255.0).round()
# Important. Unlike matlab, numpy.unit8() WILL NOT round by default.
return img_np.astype(out_type)
'''
# --------------------------------------------
# Augmentation, flipe and/or rotate
# --------------------------------------------
# The following two are enough.
# (1) augmet_img: numpy image of WxHxC or WxH
# (2) augment_img_tensor4: tensor image 1xCxWxH
# --------------------------------------------
'''
def augment_img(img, mode=0):
'''Kai Zhang (github: https://github.com/cszn)
'''
if mode == 0:
return img
elif mode == 1:
return np.flipud(np.rot90(img))
elif mode == 2:
return np.flipud(img)
elif mode == 3:
return np.rot90(img, k=3)
elif mode == 4:
return np.flipud(np.rot90(img, k=2))
elif mode == 5:
return np.rot90(img)
elif mode == 6:
return np.rot90(img, k=2)
elif mode == 7:
return np.flipud(np.rot90(img, k=3))
def augment_img_tensor4(img, mode=0):
'''Kai Zhang (github: https://github.com/cszn)
'''
if mode == 0:
return img
elif mode == 1:
return img.rot90(1, [2, 3]).flip([2])
elif mode == 2:
return img.flip([2])
elif mode == 3:
return img.rot90(3, [2, 3])
elif mode == 4:
return img.rot90(2, [2, 3]).flip([2])
elif mode == 5:
return img.rot90(1, [2, 3])
elif mode == 6:
return img.rot90(2, [2, 3])
elif mode == 7:
return img.rot90(3, [2, 3]).flip([2])
def augment_img_tensor(img, mode=0):
'''Kai Zhang (github: https://github.com/cszn)
'''
img_size = img.size()
img_np = img.data.cpu().numpy()
if len(img_size) == 3:
img_np = np.transpose(img_np, (1, 2, 0))
elif len(img_size) == 4:
img_np = np.transpose(img_np, (2, 3, 1, 0))
img_np = augment_img(img_np, mode=mode)
img_tensor = torch.from_numpy(np.ascontiguousarray(img_np))
if len(img_size) == 3:
img_tensor = img_tensor.permute(2, 0, 1)
elif len(img_size) == 4:
img_tensor = img_tensor.permute(3, 2, 0, 1)
return img_tensor.type_as(img)
def augment_img_np3(img, mode=0):
if mode == 0:
return img
elif mode == 1:
return img.transpose(1, 0, 2)
elif mode == 2:
return img[::-1, :, :]
elif mode == 3:
img = img[::-1, :, :]
img = img.transpose(1, 0, 2)
return img
elif mode == 4:
return img[:, ::-1, :]
elif mode == 5:
img = img[:, ::-1, :]
img = img.transpose(1, 0, 2)
return img
elif mode == 6:
img = img[:, ::-1, :]
img = img[::-1, :, :]
return img
elif mode == 7:
img = img[:, ::-1, :]
img = img[::-1, :, :]
img = img.transpose(1, 0, 2)
return img
def augment_imgs(img_list, hflip=True, rot=True):
# horizontal flip OR rotate
hflip = hflip and random.random() < 0.5
vflip = rot and random.random() < 0.5
rot90 = rot and random.random() < 0.5
def _augment(img):
if hflip:
img = img[:, ::-1, :]
if vflip:
img = img[::-1, :, :]
if rot90:
img = img.transpose(1, 0, 2)
return img
return [_augment(img) for img in img_list]
'''
# --------------------------------------------
# modcrop and shave
# --------------------------------------------
'''
def modcrop(img_in, scale):
# img_in: Numpy, HWC or HW
img = np.copy(img_in)
if img.ndim == 2:
H, W = img.shape
H_r, W_r = H % scale, W % scale
img = img[:H - H_r, :W - W_r]
elif img.ndim == 3:
H, W, C = img.shape
H_r, W_r = H % scale, W % scale
img = img[:H - H_r, :W - W_r, :]
else:
raise ValueError('Wrong img ndim: [{:d}].'.format(img.ndim))
return img
def shave(img_in, border=0):
# img_in: Numpy, HWC or HW
img = np.copy(img_in)
h, w = img.shape[:2]
img = img[border:h-border, border:w-border]
return img
'''
# --------------------------------------------
# image processing process on numpy image
# channel_convert(in_c, tar_type, img_list):
# rgb2ycbcr(img, only_y=True):
# bgr2ycbcr(img, only_y=True):
# ycbcr2rgb(img):
# --------------------------------------------
'''
def rgb2ycbcr(img, only_y=True):
'''same as matlab rgb2ycbcr
only_y: only return Y channel
Input:
uint8, [0, 255]
float, [0, 1]
'''
in_img_type = img.dtype
img.astype(np.float32)
if in_img_type != np.uint8:
img *= 255.
# convert
if only_y:
rlt = np.dot(img, [65.481, 128.553, 24.966]) / 255.0 + 16.0
else:
rlt = np.matmul(img, [[65.481, -37.797, 112.0], [128.553, -74.203, -93.786],
[24.966, 112.0, -18.214]]) / 255.0 + [16, 128, 128]
if in_img_type == np.uint8:
rlt = rlt.round()
else:
rlt /= 255.
return rlt.astype(in_img_type)
def ycbcr2rgb(img):
'''same as matlab ycbcr2rgb
Input:
uint8, [0, 255]
float, [0, 1]
'''
in_img_type = img.dtype
img.astype(np.float32)
if in_img_type != np.uint8:
img *= 255.
# convert
rlt = np.matmul(img, [[0.00456621, 0.00456621, 0.00456621], [0, -0.00153632, 0.00791071],
[0.00625893, -0.00318811, 0]]) * 255.0 + [-222.921, 135.576, -276.836]
if in_img_type == np.uint8:
rlt = rlt.round()
else:
rlt /= 255.
return rlt.astype(in_img_type)
def bgr2ycbcr(img, only_y=True):
'''bgr version of rgb2ycbcr
only_y: only return Y channel
Input:
uint8, [0, 255]
float, [0, 1]
'''
in_img_type = img.dtype
img.astype(np.float32)
if in_img_type != np.uint8:
img *= 255.
# convert
if only_y:
rlt = np.dot(img, [24.966, 128.553, 65.481]) / 255.0 + 16.0
else:
rlt = np.matmul(img, [[24.966, 112.0, -18.214], [128.553, -74.203, -93.786],
[65.481, -37.797, 112.0]]) / 255.0 + [16, 128, 128]
if in_img_type == np.uint8:
rlt = rlt.round()
else:
rlt /= 255.
return rlt.astype(in_img_type)
def channel_convert(in_c, tar_type, img_list):
# conversion among BGR, gray and y
if in_c == 3 and tar_type == 'gray': # BGR to gray
gray_list = [cv2.cvtColor(img, cv2.COLOR_BGR2GRAY) for img in img_list]
return [np.expand_dims(img, axis=2) for img in gray_list]
elif in_c == 3 and tar_type == 'y': # BGR to y
y_list = [bgr2ycbcr(img, only_y=True) for img in img_list]
return [np.expand_dims(img, axis=2) for img in y_list]
elif in_c == 1 and tar_type == 'RGB': # gray/y to BGR
return [cv2.cvtColor(img, cv2.COLOR_GRAY2BGR) for img in img_list]
else:
return img_list
'''
# --------------------------------------------
# metric, PSNR and SSIM
# --------------------------------------------
'''
# --------------------------------------------
# PSNR
# --------------------------------------------
def calculate_psnr(img1, img2, border=0):
# img1 and img2 have range [0, 255]
#img1 = img1.squeeze()
#img2 = img2.squeeze()
if not img1.shape == img2.shape:
raise ValueError('Input images must have the same dimensions.')
h, w = img1.shape[:2]
img1 = img1[border:h-border, border:w-border]
img2 = img2[border:h-border, border:w-border]
img1 = img1.astype(np.float64)
img2 = img2.astype(np.float64)
mse = np.mean((img1 - img2)**2)
if mse == 0:
return float('inf')
return 20 * math.log10(255.0 / math.sqrt(mse))
# --------------------------------------------
# SSIM
# --------------------------------------------
def calculate_ssim(img1, img2, border=0):
'''calculate SSIM
the same outputs as MATLAB's
img1, img2: [0, 255]
'''
#img1 = img1.squeeze()
#img2 = img2.squeeze()
if not img1.shape == img2.shape:
raise ValueError('Input images must have the same dimensions.')
h, w = img1.shape[:2]
img1 = img1[border:h-border, border:w-border]
img2 = img2[border:h-border, border:w-border]
if img1.ndim == 2:
return ssim(img1, img2)
elif img1.ndim == 3:
if img1.shape[2] == 3:
ssims = []
for i in range(3):
ssims.append(ssim(img1[:,:,i], img2[:,:,i]))
return np.array(ssims).mean()
elif img1.shape[2] == 1:
return ssim(np.squeeze(img1), np.squeeze(img2))
else:
raise ValueError('Wrong input image dimensions.')
def ssim(img1, img2):
C1 = (0.01 * 255)**2
C2 = (0.03 * 255)**2
img1 = img1.astype(np.float64)
img2 = img2.astype(np.float64)
kernel = cv2.getGaussianKernel(11, 1.5)
window = np.outer(kernel, kernel.transpose())
mu1 = cv2.filter2D(img1, -1, window)[5:-5, 5:-5] # valid
mu2 = cv2.filter2D(img2, -1, window)[5:-5, 5:-5]
mu1_sq = mu1**2
mu2_sq = mu2**2
mu1_mu2 = mu1 * mu2
sigma1_sq = cv2.filter2D(img1**2, -1, window)[5:-5, 5:-5] - mu1_sq
sigma2_sq = cv2.filter2D(img2**2, -1, window)[5:-5, 5:-5] - mu2_sq
sigma12 = cv2.filter2D(img1 * img2, -1, window)[5:-5, 5:-5] - mu1_mu2
ssim_map = ((2 * mu1_mu2 + C1) * (2 * sigma12 + C2)) / ((mu1_sq + mu2_sq + C1) *
(sigma1_sq + sigma2_sq + C2))
return ssim_map.mean()
'''
# --------------------------------------------
# matlab's bicubic imresize (numpy and torch) [0, 1]
# --------------------------------------------
'''
# matlab 'imresize' function, now only support 'bicubic'
def cubic(x):
absx = torch.abs(x)
absx2 = absx**2
absx3 = absx**3
return (1.5*absx3 - 2.5*absx2 + 1) * ((absx <= 1).type_as(absx)) + \
(-0.5*absx3 + 2.5*absx2 - 4*absx + 2) * (((absx > 1)*(absx <= 2)).type_as(absx))
def calculate_weights_indices(in_length, out_length, scale, kernel, kernel_width, antialiasing):
if (scale < 1) and (antialiasing):
# Use a modified kernel to simultaneously interpolate and antialias- larger kernel width
kernel_width = kernel_width / scale
# Output-space coordinates
x = torch.linspace(1, out_length, out_length)
# Input-space coordinates. Calculate the inverse mapping such that 0.5
# in output space maps to 0.5 in input space, and 0.5+scale in output
# space maps to 1.5 in input space.
u = x / scale + 0.5 * (1 - 1 / scale)
# What is the left-most pixel that can be involved in the computation?
left = torch.floor(u - kernel_width / 2)
# What is the maximum number of pixels that can be involved in the
# computation? Note: it's OK to use an extra pixel here; if the
# corresponding weights are all zero, it will be eliminated at the end
# of this function.
P = math.ceil(kernel_width) + 2
# The indices of the input pixels involved in computing the k-th output
# pixel are in row k of the indices matrix.
indices = left.view(out_length, 1).expand(out_length, P) + torch.linspace(0, P - 1, P).view(
1, P).expand(out_length, P)
# The weights used to compute the k-th output pixel are in row k of the
# weights matrix.
distance_to_center = u.view(out_length, 1).expand(out_length, P) - indices
# apply cubic kernel
if (scale < 1) and (antialiasing):
weights = scale * cubic(distance_to_center * scale)
else:
weights = cubic(distance_to_center)
# Normalize the weights matrix so that each row sums to 1.
weights_sum = torch.sum(weights, 1).view(out_length, 1)
weights = weights / weights_sum.expand(out_length, P)
# If a column in weights is all zero, get rid of it. only consider the first and last column.
weights_zero_tmp = torch.sum((weights == 0), 0)
if not math.isclose(weights_zero_tmp[0], 0, rel_tol=1e-6):
indices = indices.narrow(1, 1, P - 2)
weights = weights.narrow(1, 1, P - 2)
if not math.isclose(weights_zero_tmp[-1], 0, rel_tol=1e-6):
indices = indices.narrow(1, 0, P - 2)
weights = weights.narrow(1, 0, P - 2)
weights = weights.contiguous()
indices = indices.contiguous()
sym_len_s = -indices.min() + 1
sym_len_e = indices.max() - in_length
indices = indices + sym_len_s - 1
return weights, indices, int(sym_len_s), int(sym_len_e)
# --------------------------------------------
# imresize for tensor image [0, 1]
# --------------------------------------------
def imresize(img, scale, antialiasing=True):
# Now the scale should be the same for H and W
# input: img: pytorch tensor, CHW or HW [0,1]
# output: CHW or HW [0,1] w/o round
need_squeeze = True if img.dim() == 2 else False
if need_squeeze:
img.unsqueeze_(0)
in_C, in_H, in_W = img.size()
out_C, out_H, out_W = in_C, math.ceil(in_H * scale), math.ceil(in_W * scale)
kernel_width = 4
kernel = 'cubic'
# Return the desired dimension order for performing the resize. The
# strategy is to perform the resize first along the dimension with the
# smallest scale factor.
# Now we do not support this.
# get weights and indices
weights_H, indices_H, sym_len_Hs, sym_len_He = calculate_weights_indices(
in_H, out_H, scale, kernel, kernel_width, antialiasing)
weights_W, indices_W, sym_len_Ws, sym_len_We = calculate_weights_indices(
in_W, out_W, scale, kernel, kernel_width, antialiasing)
# process H dimension
# symmetric copying
img_aug = torch.FloatTensor(in_C, in_H + sym_len_Hs + sym_len_He, in_W)
img_aug.narrow(1, sym_len_Hs, in_H).copy_(img)
sym_patch = img[:, :sym_len_Hs, :]
inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long()
sym_patch_inv = sym_patch.index_select(1, inv_idx)
img_aug.narrow(1, 0, sym_len_Hs).copy_(sym_patch_inv)
sym_patch = img[:, -sym_len_He:, :]
inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long()
sym_patch_inv = sym_patch.index_select(1, inv_idx)
img_aug.narrow(1, sym_len_Hs + in_H, sym_len_He).copy_(sym_patch_inv)
out_1 = torch.FloatTensor(in_C, out_H, in_W)
kernel_width = weights_H.size(1)
for i in range(out_H):
idx = int(indices_H[i][0])
for j in range(out_C):
out_1[j, i, :] = img_aug[j, idx:idx + kernel_width, :].transpose(0, 1).mv(weights_H[i])
# process W dimension
# symmetric copying
out_1_aug = torch.FloatTensor(in_C, out_H, in_W + sym_len_Ws + sym_len_We)
out_1_aug.narrow(2, sym_len_Ws, in_W).copy_(out_1)
sym_patch = out_1[:, :, :sym_len_Ws]
inv_idx = torch.arange(sym_patch.size(2) - 1, -1, -1).long()
sym_patch_inv = sym_patch.index_select(2, inv_idx)
out_1_aug.narrow(2, 0, sym_len_Ws).copy_(sym_patch_inv)
sym_patch = out_1[:, :, -sym_len_We:]
inv_idx = torch.arange(sym_patch.size(2) - 1, -1, -1).long()
sym_patch_inv = sym_patch.index_select(2, inv_idx)
out_1_aug.narrow(2, sym_len_Ws + in_W, sym_len_We).copy_(sym_patch_inv)
out_2 = torch.FloatTensor(in_C, out_H, out_W)
kernel_width = weights_W.size(1)
for i in range(out_W):
idx = int(indices_W[i][0])
for j in range(out_C):
out_2[j, :, i] = out_1_aug[j, :, idx:idx + kernel_width].mv(weights_W[i])
if need_squeeze:
out_2.squeeze_()
return out_2
# --------------------------------------------
# imresize for numpy image [0, 1]
# --------------------------------------------
def imresize_np(img, scale, antialiasing=True):
# Now the scale should be the same for H and W
# input: img: Numpy, HWC or HW [0,1]
# output: HWC or HW [0,1] w/o round
img = torch.from_numpy(img)
need_squeeze = True if img.dim() == 2 else False
if need_squeeze:
img.unsqueeze_(2)
in_H, in_W, in_C = img.size()
out_C, out_H, out_W = in_C, math.ceil(in_H * scale), math.ceil(in_W * scale)
kernel_width = 4
kernel = 'cubic'
# Return the desired dimension order for performing the resize. The
# strategy is to perform the resize first along the dimension with the
# smallest scale factor.
# Now we do not support this.
# get weights and indices
weights_H, indices_H, sym_len_Hs, sym_len_He = calculate_weights_indices(
in_H, out_H, scale, kernel, kernel_width, antialiasing)
weights_W, indices_W, sym_len_Ws, sym_len_We = calculate_weights_indices(
in_W, out_W, scale, kernel, kernel_width, antialiasing)
# process H dimension
# symmetric copying
img_aug = torch.FloatTensor(in_H + sym_len_Hs + sym_len_He, in_W, in_C)
img_aug.narrow(0, sym_len_Hs, in_H).copy_(img)
sym_patch = img[:sym_len_Hs, :, :]
inv_idx = torch.arange(sym_patch.size(0) - 1, -1, -1).long()
sym_patch_inv = sym_patch.index_select(0, inv_idx)
img_aug.narrow(0, 0, sym_len_Hs).copy_(sym_patch_inv)
sym_patch = img[-sym_len_He:, :, :]
inv_idx = torch.arange(sym_patch.size(0) - 1, -1, -1).long()
sym_patch_inv = sym_patch.index_select(0, inv_idx)
img_aug.narrow(0, sym_len_Hs + in_H, sym_len_He).copy_(sym_patch_inv)
out_1 = torch.FloatTensor(out_H, in_W, in_C)
kernel_width = weights_H.size(1)
for i in range(out_H):
idx = int(indices_H[i][0])
for j in range(out_C):
out_1[i, :, j] = img_aug[idx:idx + kernel_width, :, j].transpose(0, 1).mv(weights_H[i])
# process W dimension
# symmetric copying
out_1_aug = torch.FloatTensor(out_H, in_W + sym_len_Ws + sym_len_We, in_C)
out_1_aug.narrow(1, sym_len_Ws, in_W).copy_(out_1)
sym_patch = out_1[:, :sym_len_Ws, :]
inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long()
sym_patch_inv = sym_patch.index_select(1, inv_idx)
out_1_aug.narrow(1, 0, sym_len_Ws).copy_(sym_patch_inv)
sym_patch = out_1[:, -sym_len_We:, :]
inv_idx = torch.arange(sym_patch.size(1) - 1, -1, -1).long()
sym_patch_inv = sym_patch.index_select(1, inv_idx)
out_1_aug.narrow(1, sym_len_Ws + in_W, sym_len_We).copy_(sym_patch_inv)
out_2 = torch.FloatTensor(out_H, out_W, in_C)
kernel_width = weights_W.size(1)
for i in range(out_W):
idx = int(indices_W[i][0])
for j in range(out_C):
out_2[:, i, j] = out_1_aug[:, idx:idx + kernel_width, j].mv(weights_W[i])
if need_squeeze:
out_2.squeeze_()
return out_2.numpy()
if __name__ == '__main__':
print('---')
# img = imread_uint('test.bmp', 3)
# img = uint2single(img)
# img_bicubic = imresize_np(img, 1/4) | EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/image_degradation/utils_image.py |
# -*- coding: utf-8 -*-
import numpy as np
import cv2
import torch
from functools import partial
import random
from scipy import ndimage
import scipy
import scipy.stats as ss
from scipy.interpolate import interp2d
from scipy.linalg import orth
import albumentations
import ldm.modules.image_degradation.utils_image as util
"""
# --------------------------------------------
# Super-Resolution
# --------------------------------------------
#
# Kai Zhang ([email protected])
# https://github.com/cszn
# From 2019/03--2021/08
# --------------------------------------------
"""
def modcrop_np(img, sf):
'''
Args:
img: numpy image, WxH or WxHxC
sf: scale factor
Return:
cropped image
'''
w, h = img.shape[:2]
im = np.copy(img)
return im[:w - w % sf, :h - h % sf, ...]
"""
# --------------------------------------------
# anisotropic Gaussian kernels
# --------------------------------------------
"""
def analytic_kernel(k):
"""Calculate the X4 kernel from the X2 kernel (for proof see appendix in paper)"""
k_size = k.shape[0]
# Calculate the big kernels size
big_k = np.zeros((3 * k_size - 2, 3 * k_size - 2))
# Loop over the small kernel to fill the big one
for r in range(k_size):
for c in range(k_size):
big_k[2 * r:2 * r + k_size, 2 * c:2 * c + k_size] += k[r, c] * k
# Crop the edges of the big kernel to ignore very small values and increase run time of SR
crop = k_size // 2
cropped_big_k = big_k[crop:-crop, crop:-crop]
# Normalize to 1
return cropped_big_k / cropped_big_k.sum()
def anisotropic_Gaussian(ksize=15, theta=np.pi, l1=6, l2=6):
""" generate an anisotropic Gaussian kernel
Args:
ksize : e.g., 15, kernel size
theta : [0, pi], rotation angle range
l1 : [0.1,50], scaling of eigenvalues
l2 : [0.1,l1], scaling of eigenvalues
If l1 = l2, will get an isotropic Gaussian kernel.
Returns:
k : kernel
"""
v = np.dot(np.array([[np.cos(theta), -np.sin(theta)], [np.sin(theta), np.cos(theta)]]), np.array([1., 0.]))
V = np.array([[v[0], v[1]], [v[1], -v[0]]])
D = np.array([[l1, 0], [0, l2]])
Sigma = np.dot(np.dot(V, D), np.linalg.inv(V))
k = gm_blur_kernel(mean=[0, 0], cov=Sigma, size=ksize)
return k
def gm_blur_kernel(mean, cov, size=15):
center = size / 2.0 + 0.5
k = np.zeros([size, size])
for y in range(size):
for x in range(size):
cy = y - center + 1
cx = x - center + 1
k[y, x] = ss.multivariate_normal.pdf([cx, cy], mean=mean, cov=cov)
k = k / np.sum(k)
return k
def shift_pixel(x, sf, upper_left=True):
"""shift pixel for super-resolution with different scale factors
Args:
x: WxHxC or WxH
sf: scale factor
upper_left: shift direction
"""
h, w = x.shape[:2]
shift = (sf - 1) * 0.5
xv, yv = np.arange(0, w, 1.0), np.arange(0, h, 1.0)
if upper_left:
x1 = xv + shift
y1 = yv + shift
else:
x1 = xv - shift
y1 = yv - shift
x1 = np.clip(x1, 0, w - 1)
y1 = np.clip(y1, 0, h - 1)
if x.ndim == 2:
x = interp2d(xv, yv, x)(x1, y1)
if x.ndim == 3:
for i in range(x.shape[-1]):
x[:, :, i] = interp2d(xv, yv, x[:, :, i])(x1, y1)
return x
def blur(x, k):
'''
x: image, NxcxHxW
k: kernel, Nx1xhxw
'''
n, c = x.shape[:2]
p1, p2 = (k.shape[-2] - 1) // 2, (k.shape[-1] - 1) // 2
x = torch.nn.functional.pad(x, pad=(p1, p2, p1, p2), mode='replicate')
k = k.repeat(1, c, 1, 1)
k = k.view(-1, 1, k.shape[2], k.shape[3])
x = x.view(1, -1, x.shape[2], x.shape[3])
x = torch.nn.functional.conv2d(x, k, bias=None, stride=1, padding=0, groups=n * c)
x = x.view(n, c, x.shape[2], x.shape[3])
return x
def gen_kernel(k_size=np.array([15, 15]), scale_factor=np.array([4, 4]), min_var=0.6, max_var=10., noise_level=0):
""""
# modified version of https://github.com/assafshocher/BlindSR_dataset_generator
# Kai Zhang
# min_var = 0.175 * sf # variance of the gaussian kernel will be sampled between min_var and max_var
# max_var = 2.5 * sf
"""
# Set random eigen-vals (lambdas) and angle (theta) for COV matrix
lambda_1 = min_var + np.random.rand() * (max_var - min_var)
lambda_2 = min_var + np.random.rand() * (max_var - min_var)
theta = np.random.rand() * np.pi # random theta
noise = -noise_level + np.random.rand(*k_size) * noise_level * 2
# Set COV matrix using Lambdas and Theta
LAMBDA = np.diag([lambda_1, lambda_2])
Q = np.array([[np.cos(theta), -np.sin(theta)],
[np.sin(theta), np.cos(theta)]])
SIGMA = Q @ LAMBDA @ Q.T
INV_SIGMA = np.linalg.inv(SIGMA)[None, None, :, :]
# Set expectation position (shifting kernel for aligned image)
MU = k_size // 2 - 0.5 * (scale_factor - 1) # - 0.5 * (scale_factor - k_size % 2)
MU = MU[None, None, :, None]
# Create meshgrid for Gaussian
[X, Y] = np.meshgrid(range(k_size[0]), range(k_size[1]))
Z = np.stack([X, Y], 2)[:, :, :, None]
# Calcualte Gaussian for every pixel of the kernel
ZZ = Z - MU
ZZ_t = ZZ.transpose(0, 1, 3, 2)
raw_kernel = np.exp(-0.5 * np.squeeze(ZZ_t @ INV_SIGMA @ ZZ)) * (1 + noise)
# shift the kernel so it will be centered
# raw_kernel_centered = kernel_shift(raw_kernel, scale_factor)
# Normalize the kernel and return
# kernel = raw_kernel_centered / np.sum(raw_kernel_centered)
kernel = raw_kernel / np.sum(raw_kernel)
return kernel
def fspecial_gaussian(hsize, sigma):
hsize = [hsize, hsize]
siz = [(hsize[0] - 1.0) / 2.0, (hsize[1] - 1.0) / 2.0]
std = sigma
[x, y] = np.meshgrid(np.arange(-siz[1], siz[1] + 1), np.arange(-siz[0], siz[0] + 1))
arg = -(x * x + y * y) / (2 * std * std)
h = np.exp(arg)
h[h < scipy.finfo(float).eps * h.max()] = 0
sumh = h.sum()
if sumh != 0:
h = h / sumh
return h
def fspecial_laplacian(alpha):
alpha = max([0, min([alpha, 1])])
h1 = alpha / (alpha + 1)
h2 = (1 - alpha) / (alpha + 1)
h = [[h1, h2, h1], [h2, -4 / (alpha + 1), h2], [h1, h2, h1]]
h = np.array(h)
return h
def fspecial(filter_type, *args, **kwargs):
'''
python code from:
https://github.com/ronaldosena/imagens-medicas-2/blob/40171a6c259edec7827a6693a93955de2bd39e76/Aulas/aula_2_-_uniform_filter/matlab_fspecial.py
'''
if filter_type == 'gaussian':
return fspecial_gaussian(*args, **kwargs)
if filter_type == 'laplacian':
return fspecial_laplacian(*args, **kwargs)
"""
# --------------------------------------------
# degradation models
# --------------------------------------------
"""
def bicubic_degradation(x, sf=3):
'''
Args:
x: HxWxC image, [0, 1]
sf: down-scale factor
Return:
bicubicly downsampled LR image
'''
x = util.imresize_np(x, scale=1 / sf)
return x
def srmd_degradation(x, k, sf=3):
''' blur + bicubic downsampling
Args:
x: HxWxC image, [0, 1]
k: hxw, double
sf: down-scale factor
Return:
downsampled LR image
Reference:
@inproceedings{zhang2018learning,
title={Learning a single convolutional super-resolution network for multiple degradations},
author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei},
booktitle={IEEE Conference on Computer Vision and Pattern Recognition},
pages={3262--3271},
year={2018}
}
'''
x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap') # 'nearest' | 'mirror'
x = bicubic_degradation(x, sf=sf)
return x
def dpsr_degradation(x, k, sf=3):
''' bicubic downsampling + blur
Args:
x: HxWxC image, [0, 1]
k: hxw, double
sf: down-scale factor
Return:
downsampled LR image
Reference:
@inproceedings{zhang2019deep,
title={Deep Plug-and-Play Super-Resolution for Arbitrary Blur Kernels},
author={Zhang, Kai and Zuo, Wangmeng and Zhang, Lei},
booktitle={IEEE Conference on Computer Vision and Pattern Recognition},
pages={1671--1681},
year={2019}
}
'''
x = bicubic_degradation(x, sf=sf)
x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap')
return x
def classical_degradation(x, k, sf=3):
''' blur + downsampling
Args:
x: HxWxC image, [0, 1]/[0, 255]
k: hxw, double
sf: down-scale factor
Return:
downsampled LR image
'''
x = ndimage.filters.convolve(x, np.expand_dims(k, axis=2), mode='wrap')
# x = filters.correlate(x, np.expand_dims(np.flip(k), axis=2))
st = 0
return x[st::sf, st::sf, ...]
def add_sharpening(img, weight=0.5, radius=50, threshold=10):
"""USM sharpening. borrowed from real-ESRGAN
Input image: I; Blurry image: B.
1. K = I + weight * (I - B)
2. Mask = 1 if abs(I - B) > threshold, else: 0
3. Blur mask:
4. Out = Mask * K + (1 - Mask) * I
Args:
img (Numpy array): Input image, HWC, BGR; float32, [0, 1].
weight (float): Sharp weight. Default: 1.
radius (float): Kernel size of Gaussian blur. Default: 50.
threshold (int):
"""
if radius % 2 == 0:
radius += 1
blur = cv2.GaussianBlur(img, (radius, radius), 0)
residual = img - blur
mask = np.abs(residual) * 255 > threshold
mask = mask.astype('float32')
soft_mask = cv2.GaussianBlur(mask, (radius, radius), 0)
K = img + weight * residual
K = np.clip(K, 0, 1)
return soft_mask * K + (1 - soft_mask) * img
def add_blur(img, sf=4):
wd2 = 4.0 + sf
wd = 2.0 + 0.2 * sf
wd2 = wd2/4
wd = wd/4
if random.random() < 0.5:
l1 = wd2 * random.random()
l2 = wd2 * random.random()
k = anisotropic_Gaussian(ksize=random.randint(2, 11) + 3, theta=random.random() * np.pi, l1=l1, l2=l2)
else:
k = fspecial('gaussian', random.randint(2, 4) + 3, wd * random.random())
img = ndimage.filters.convolve(img, np.expand_dims(k, axis=2), mode='mirror')
return img
def add_resize(img, sf=4):
rnum = np.random.rand()
if rnum > 0.8: # up
sf1 = random.uniform(1, 2)
elif rnum < 0.7: # down
sf1 = random.uniform(0.5 / sf, 1)
else:
sf1 = 1.0
img = cv2.resize(img, (int(sf1 * img.shape[1]), int(sf1 * img.shape[0])), interpolation=random.choice([1, 2, 3]))
img = np.clip(img, 0.0, 1.0)
return img
# def add_Gaussian_noise(img, noise_level1=2, noise_level2=25):
# noise_level = random.randint(noise_level1, noise_level2)
# rnum = np.random.rand()
# if rnum > 0.6: # add color Gaussian noise
# img += np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32)
# elif rnum < 0.4: # add grayscale Gaussian noise
# img += np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32)
# else: # add noise
# L = noise_level2 / 255.
# D = np.diag(np.random.rand(3))
# U = orth(np.random.rand(3, 3))
# conv = np.dot(np.dot(np.transpose(U), D), U)
# img += np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
# img = np.clip(img, 0.0, 1.0)
# return img
def add_Gaussian_noise(img, noise_level1=2, noise_level2=25):
noise_level = random.randint(noise_level1, noise_level2)
rnum = np.random.rand()
if rnum > 0.6: # add color Gaussian noise
img = img + np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32)
elif rnum < 0.4: # add grayscale Gaussian noise
img = img + np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32)
else: # add noise
L = noise_level2 / 255.
D = np.diag(np.random.rand(3))
U = orth(np.random.rand(3, 3))
conv = np.dot(np.dot(np.transpose(U), D), U)
img = img + np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
img = np.clip(img, 0.0, 1.0)
return img
def add_speckle_noise(img, noise_level1=2, noise_level2=25):
noise_level = random.randint(noise_level1, noise_level2)
img = np.clip(img, 0.0, 1.0)
rnum = random.random()
if rnum > 0.6:
img += img * np.random.normal(0, noise_level / 255.0, img.shape).astype(np.float32)
elif rnum < 0.4:
img += img * np.random.normal(0, noise_level / 255.0, (*img.shape[:2], 1)).astype(np.float32)
else:
L = noise_level2 / 255.
D = np.diag(np.random.rand(3))
U = orth(np.random.rand(3, 3))
conv = np.dot(np.dot(np.transpose(U), D), U)
img += img * np.random.multivariate_normal([0, 0, 0], np.abs(L ** 2 * conv), img.shape[:2]).astype(np.float32)
img = np.clip(img, 0.0, 1.0)
return img
def add_Poisson_noise(img):
img = np.clip((img * 255.0).round(), 0, 255) / 255.
vals = 10 ** (2 * random.random() + 2.0) # [2, 4]
if random.random() < 0.5:
img = np.random.poisson(img * vals).astype(np.float32) / vals
else:
img_gray = np.dot(img[..., :3], [0.299, 0.587, 0.114])
img_gray = np.clip((img_gray * 255.0).round(), 0, 255) / 255.
noise_gray = np.random.poisson(img_gray * vals).astype(np.float32) / vals - img_gray
img += noise_gray[:, :, np.newaxis]
img = np.clip(img, 0.0, 1.0)
return img
def add_JPEG_noise(img):
quality_factor = random.randint(80, 95)
img = cv2.cvtColor(util.single2uint(img), cv2.COLOR_RGB2BGR)
result, encimg = cv2.imencode('.jpg', img, [int(cv2.IMWRITE_JPEG_QUALITY), quality_factor])
img = cv2.imdecode(encimg, 1)
img = cv2.cvtColor(util.uint2single(img), cv2.COLOR_BGR2RGB)
return img
def random_crop(lq, hq, sf=4, lq_patchsize=64):
h, w = lq.shape[:2]
rnd_h = random.randint(0, h - lq_patchsize)
rnd_w = random.randint(0, w - lq_patchsize)
lq = lq[rnd_h:rnd_h + lq_patchsize, rnd_w:rnd_w + lq_patchsize, :]
rnd_h_H, rnd_w_H = int(rnd_h * sf), int(rnd_w * sf)
hq = hq[rnd_h_H:rnd_h_H + lq_patchsize * sf, rnd_w_H:rnd_w_H + lq_patchsize * sf, :]
return lq, hq
def degradation_bsrgan(img, sf=4, lq_patchsize=72, isp_model=None):
"""
This is the degradation model of BSRGAN from the paper
"Designing a Practical Degradation Model for Deep Blind Image Super-Resolution"
----------
img: HXWXC, [0, 1], its size should be large than (lq_patchsizexsf)x(lq_patchsizexsf)
sf: scale factor
isp_model: camera ISP model
Returns
-------
img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1]
hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1]
"""
isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25
sf_ori = sf
h1, w1 = img.shape[:2]
img = img.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop
h, w = img.shape[:2]
if h < lq_patchsize * sf or w < lq_patchsize * sf:
raise ValueError(f'img size ({h1}X{w1}) is too small!')
hq = img.copy()
if sf == 4 and random.random() < scale2_prob: # downsample1
if np.random.rand() < 0.5:
img = cv2.resize(img, (int(1 / 2 * img.shape[1]), int(1 / 2 * img.shape[0])),
interpolation=random.choice([1, 2, 3]))
else:
img = util.imresize_np(img, 1 / 2, True)
img = np.clip(img, 0.0, 1.0)
sf = 2
shuffle_order = random.sample(range(7), 7)
idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3)
if idx1 > idx2: # keep downsample3 last
shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1]
for i in shuffle_order:
if i == 0:
img = add_blur(img, sf=sf)
elif i == 1:
img = add_blur(img, sf=sf)
elif i == 2:
a, b = img.shape[1], img.shape[0]
# downsample2
if random.random() < 0.75:
sf1 = random.uniform(1, 2 * sf)
img = cv2.resize(img, (int(1 / sf1 * img.shape[1]), int(1 / sf1 * img.shape[0])),
interpolation=random.choice([1, 2, 3]))
else:
k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf))
k_shifted = shift_pixel(k, sf)
k_shifted = k_shifted / k_shifted.sum() # blur with shifted kernel
img = ndimage.filters.convolve(img, np.expand_dims(k_shifted, axis=2), mode='mirror')
img = img[0::sf, 0::sf, ...] # nearest downsampling
img = np.clip(img, 0.0, 1.0)
elif i == 3:
# downsample3
img = cv2.resize(img, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3]))
img = np.clip(img, 0.0, 1.0)
elif i == 4:
# add Gaussian noise
img = add_Gaussian_noise(img, noise_level1=2, noise_level2=8)
elif i == 5:
# add JPEG noise
if random.random() < jpeg_prob:
img = add_JPEG_noise(img)
elif i == 6:
# add processed camera sensor noise
if random.random() < isp_prob and isp_model is not None:
with torch.no_grad():
img, hq = isp_model.forward(img.copy(), hq)
# add final JPEG compression noise
img = add_JPEG_noise(img)
# random crop
img, hq = random_crop(img, hq, sf_ori, lq_patchsize)
return img, hq
# todo no isp_model?
def degradation_bsrgan_variant(image, sf=4, isp_model=None):
"""
This is the degradation model of BSRGAN from the paper
"Designing a Practical Degradation Model for Deep Blind Image Super-Resolution"
----------
sf: scale factor
isp_model: camera ISP model
Returns
-------
img: low-quality patch, size: lq_patchsizeXlq_patchsizeXC, range: [0, 1]
hq: corresponding high-quality patch, size: (lq_patchsizexsf)X(lq_patchsizexsf)XC, range: [0, 1]
"""
image = util.uint2single(image)
isp_prob, jpeg_prob, scale2_prob = 0.25, 0.9, 0.25
sf_ori = sf
h1, w1 = image.shape[:2]
image = image.copy()[:w1 - w1 % sf, :h1 - h1 % sf, ...] # mod crop
h, w = image.shape[:2]
hq = image.copy()
if sf == 4 and random.random() < scale2_prob: # downsample1
if np.random.rand() < 0.5:
image = cv2.resize(image, (int(1 / 2 * image.shape[1]), int(1 / 2 * image.shape[0])),
interpolation=random.choice([1, 2, 3]))
else:
image = util.imresize_np(image, 1 / 2, True)
image = np.clip(image, 0.0, 1.0)
sf = 2
shuffle_order = random.sample(range(7), 7)
idx1, idx2 = shuffle_order.index(2), shuffle_order.index(3)
if idx1 > idx2: # keep downsample3 last
shuffle_order[idx1], shuffle_order[idx2] = shuffle_order[idx2], shuffle_order[idx1]
for i in shuffle_order:
if i == 0:
image = add_blur(image, sf=sf)
# elif i == 1:
# image = add_blur(image, sf=sf)
if i == 0:
pass
elif i == 2:
a, b = image.shape[1], image.shape[0]
# downsample2
if random.random() < 0.8:
sf1 = random.uniform(1, 2 * sf)
image = cv2.resize(image, (int(1 / sf1 * image.shape[1]), int(1 / sf1 * image.shape[0])),
interpolation=random.choice([1, 2, 3]))
else:
k = fspecial('gaussian', 25, random.uniform(0.1, 0.6 * sf))
k_shifted = shift_pixel(k, sf)
k_shifted = k_shifted / k_shifted.sum() # blur with shifted kernel
image = ndimage.filters.convolve(image, np.expand_dims(k_shifted, axis=2), mode='mirror')
image = image[0::sf, 0::sf, ...] # nearest downsampling
image = np.clip(image, 0.0, 1.0)
elif i == 3:
# downsample3
image = cv2.resize(image, (int(1 / sf * a), int(1 / sf * b)), interpolation=random.choice([1, 2, 3]))
image = np.clip(image, 0.0, 1.0)
elif i == 4:
# add Gaussian noise
image = add_Gaussian_noise(image, noise_level1=1, noise_level2=2)
elif i == 5:
# add JPEG noise
if random.random() < jpeg_prob:
image = add_JPEG_noise(image)
#
# elif i == 6:
# # add processed camera sensor noise
# if random.random() < isp_prob and isp_model is not None:
# with torch.no_grad():
# img, hq = isp_model.forward(img.copy(), hq)
# add final JPEG compression noise
image = add_JPEG_noise(image)
image = util.single2uint(image)
example = {"image": image}
return example
if __name__ == '__main__':
print("hey")
img = util.imread_uint('utils/test.png', 3)
img = img[:448, :448]
h = img.shape[0] // 4
print("resizing to", h)
sf = 4
deg_fn = partial(degradation_bsrgan_variant, sf=sf)
for i in range(20):
print(i)
img_hq = img
img_lq = deg_fn(img)["image"]
img_hq, img_lq = util.uint2single(img_hq), util.uint2single(img_lq)
print(img_lq)
img_lq_bicubic = albumentations.SmallestMaxSize(max_size=h, interpolation=cv2.INTER_CUBIC)(image=img_hq)["image"]
print(img_lq.shape)
print("bicubic", img_lq_bicubic.shape)
print(img_hq.shape)
lq_nearest = cv2.resize(util.single2uint(img_lq), (int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])),
interpolation=0)
lq_bicubic_nearest = cv2.resize(util.single2uint(img_lq_bicubic),
(int(sf * img_lq.shape[1]), int(sf * img_lq.shape[0])),
interpolation=0)
img_concat = np.concatenate([lq_bicubic_nearest, lq_nearest, util.single2uint(img_hq)], axis=1)
util.imsave(img_concat, str(i) + '.png')
| EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/image_degradation/bsrgan_light.py |
# adopted from
# https://github.com/openai/improved-diffusion/blob/main/improved_diffusion/gaussian_diffusion.py
# and
# https://github.com/lucidrains/denoising-diffusion-pytorch/blob/7706bdfc6f527f58d33f84b7b522e61e6e3164b3/denoising_diffusion_pytorch/denoising_diffusion_pytorch.py
# and
# https://github.com/openai/guided-diffusion/blob/0ba878e517b276c45d1195eb29f6f5f72659a05b/guided_diffusion/nn.py
#
# thanks!
import os
import math
import torch
import torch.nn as nn
import numpy as np
from einops import repeat
from ldm.util import instantiate_from_config
def make_beta_schedule(schedule, n_timestep, linear_start=1e-4, linear_end=2e-2, cosine_s=8e-3):
if schedule == "linear":
betas = (
torch.linspace(linear_start ** 0.5, linear_end ** 0.5, n_timestep, dtype=torch.float64) ** 2
)
elif schedule == "cosine":
timesteps = (
torch.arange(n_timestep + 1, dtype=torch.float64) / n_timestep + cosine_s
)
alphas = timesteps / (1 + cosine_s) * np.pi / 2
alphas = torch.cos(alphas).pow(2)
alphas = alphas / alphas[0]
betas = 1 - alphas[1:] / alphas[:-1]
betas = np.clip(betas, a_min=0, a_max=0.999)
elif schedule == "sqrt_linear":
betas = torch.linspace(linear_start, linear_end, n_timestep, dtype=torch.float64)
elif schedule == "sqrt":
betas = torch.linspace(linear_start, linear_end, n_timestep, dtype=torch.float64) ** 0.5
else:
raise ValueError(f"schedule '{schedule}' unknown.")
return betas.numpy()
def make_ddim_timesteps(ddim_discr_method, num_ddim_timesteps, num_ddpm_timesteps, verbose=True):
if ddim_discr_method == 'uniform':
c = num_ddpm_timesteps // num_ddim_timesteps
ddim_timesteps = np.asarray(list(range(0, num_ddpm_timesteps, c)))
elif ddim_discr_method == 'quad':
ddim_timesteps = ((np.linspace(0, np.sqrt(num_ddpm_timesteps * .8), num_ddim_timesteps)) ** 2).astype(int)
else:
raise NotImplementedError(f'There is no ddim discretization method called "{ddim_discr_method}"')
# assert ddim_timesteps.shape[0] == num_ddim_timesteps
# add one to get the final alpha values right (the ones from first scale to data during sampling)
steps_out = ddim_timesteps + 1
if verbose:
print(f'Selected timesteps for ddim sampler: {steps_out}')
return steps_out
def make_ddim_sampling_parameters(alphacums, ddim_timesteps, eta, verbose=True):
# select alphas for computing the variance schedule
alphas = alphacums[ddim_timesteps]
alphas_prev = np.asarray([alphacums[0]] + alphacums[ddim_timesteps[:-1]].tolist())
# according the the formula provided in https://arxiv.org/abs/2010.02502
sigmas = eta * np.sqrt((1 - alphas_prev) / (1 - alphas) * (1 - alphas / alphas_prev))
if verbose:
print(f'Selected alphas for ddim sampler: a_t: {alphas}; a_(t-1): {alphas_prev}')
print(f'For the chosen value of eta, which is {eta}, '
f'this results in the following sigma_t schedule for ddim sampler {sigmas}')
return sigmas, alphas, alphas_prev
def betas_for_alpha_bar(num_diffusion_timesteps, alpha_bar, max_beta=0.999):
"""
Create a beta schedule that discretizes the given alpha_t_bar function,
which defines the cumulative product of (1-beta) over time from t = [0,1].
:param num_diffusion_timesteps: the number of betas to produce.
:param alpha_bar: a lambda that takes an argument t from 0 to 1 and
produces the cumulative product of (1-beta) up to that
part of the diffusion process.
:param max_beta: the maximum beta to use; use values lower than 1 to
prevent singularities.
"""
betas = []
for i in range(num_diffusion_timesteps):
t1 = i / num_diffusion_timesteps
t2 = (i + 1) / num_diffusion_timesteps
betas.append(min(1 - alpha_bar(t2) / alpha_bar(t1), max_beta))
return np.array(betas)
def extract_into_tensor(a, t, x_shape):
b, *_ = t.shape
out = a.gather(-1, t)
return out.reshape(b, *((1,) * (len(x_shape) - 1)))
def checkpoint(func, inputs, params, flag):
"""
Evaluate a function without caching intermediate activations, allowing for
reduced memory at the expense of extra compute in the backward pass.
:param func: the function to evaluate.
:param inputs: the argument sequence to pass to `func`.
:param params: a sequence of parameters `func` depends on but does not
explicitly take as arguments.
:param flag: if False, disable gradient checkpointing.
"""
if flag:
args = tuple(inputs) + tuple(params)
return CheckpointFunction.apply(func, len(inputs), *args)
else:
return func(*inputs)
class CheckpointFunction(torch.autograd.Function):
@staticmethod
def forward(ctx, run_function, length, *args):
ctx.run_function = run_function
ctx.input_tensors = list(args[:length])
ctx.input_params = list(args[length:])
with torch.no_grad():
output_tensors = ctx.run_function(*ctx.input_tensors)
return output_tensors
@staticmethod
def backward(ctx, *output_grads):
ctx.input_tensors = [x.detach().requires_grad_(True) for x in ctx.input_tensors]
with torch.enable_grad():
# Fixes a bug where the first op in run_function modifies the
# Tensor storage in place, which is not allowed for detach()'d
# Tensors.
shallow_copies = [x.view_as(x) for x in ctx.input_tensors]
output_tensors = ctx.run_function(*shallow_copies)
input_grads = torch.autograd.grad(
output_tensors,
ctx.input_tensors + ctx.input_params,
output_grads,
allow_unused=True,
)
del ctx.input_tensors
del ctx.input_params
del output_tensors
return (None, None) + input_grads
def timestep_embedding(timesteps, dim, max_period=10000, repeat_only=False):
"""
Create sinusoidal timestep embeddings.
:param timesteps: a 1-D Tensor of N indices, one per batch element.
These may be fractional.
:param dim: the dimension of the output.
:param max_period: controls the minimum frequency of the embeddings.
:return: an [N x dim] Tensor of positional embeddings.
"""
if not repeat_only:
half = dim // 2
freqs = torch.exp(
-math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half
).to(device=timesteps.device)
args = timesteps[:, None].float() * freqs[None]
embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)
if dim % 2:
embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)
else:
embedding = repeat(timesteps, 'b -> b d', d=dim)
return embedding
def zero_module(module):
"""
Zero out the parameters of a module and return it.
"""
for p in module.parameters():
p.detach().zero_()
return module
def scale_module(module, scale):
"""
Scale the parameters of a module and return it.
"""
for p in module.parameters():
p.detach().mul_(scale)
return module
def mean_flat(tensor):
"""
Take the mean over all non-batch dimensions.
"""
return tensor.mean(dim=list(range(1, len(tensor.shape))))
def normalization(channels):
"""
Make a standard normalization layer.
:param channels: number of input channels.
:return: an nn.Module for normalization.
"""
return GroupNorm32(32, channels)
# PyTorch 1.7 has SiLU, but we support PyTorch 1.5.
class SiLU(nn.Module):
def forward(self, x):
return x * torch.sigmoid(x)
class GroupNorm32(nn.GroupNorm):
def forward(self, x):
return super().forward(x.float()).type(x.dtype)
def conv_nd(dims, *args, **kwargs):
"""
Create a 1D, 2D, or 3D convolution module.
"""
if dims == 1:
return nn.Conv1d(*args, **kwargs)
elif dims == 2:
return nn.Conv2d(*args, **kwargs)
elif dims == 3:
return nn.Conv3d(*args, **kwargs)
raise ValueError(f"unsupported dimensions: {dims}")
def linear(*args, **kwargs):
"""
Create a linear module.
"""
return nn.Linear(*args, **kwargs)
def avg_pool_nd(dims, *args, **kwargs):
"""
Create a 1D, 2D, or 3D average pooling module.
"""
if dims == 1:
return nn.AvgPool1d(*args, **kwargs)
elif dims == 2:
return nn.AvgPool2d(*args, **kwargs)
elif dims == 3:
return nn.AvgPool3d(*args, **kwargs)
raise ValueError(f"unsupported dimensions: {dims}")
class HybridConditioner(nn.Module):
def __init__(self, c_concat_config, c_crossattn_config):
super().__init__()
self.concat_conditioner = instantiate_from_config(c_concat_config)
self.crossattn_conditioner = instantiate_from_config(c_crossattn_config)
def forward(self, c_concat, c_crossattn):
c_concat = self.concat_conditioner(c_concat)
c_crossattn = self.crossattn_conditioner(c_crossattn)
return {'c_concat': [c_concat], 'c_crossattn': [c_crossattn]}
def noise_like(shape, device, repeat=False):
repeat_noise = lambda: torch.randn((1, *shape[1:]), device=device).repeat(shape[0], *((1,) * (len(shape) - 1)))
noise = lambda: torch.randn(shape, device=device)
return repeat_noise() if repeat else noise() | EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/diffusionmodules/util.py |
EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/diffusionmodules/__init__.py |
|
# pytorch_diffusion + derived encoder decoder
import math
import torch
import torch.nn as nn
import numpy as np
from einops import rearrange
from ldm.util import instantiate_from_config
from ldm.modules.attention import LinearAttention
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, num_groups=32):
return torch.nn.GroupNorm(num_groups=num_groups, 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 LinAttnBlock(LinearAttention):
"""to match AttnBlock usage"""
def __init__(self, in_channels):
super().__init__(dim=in_channels, heads=1, dim_head=in_channels)
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_
def make_attn(in_channels, attn_type="vanilla"):
assert attn_type in ["vanilla", "linear", "none"], f'attn_type {attn_type} unknown'
print(f"making attention of type '{attn_type}' with {in_channels} in_channels")
if attn_type == "vanilla":
return AttnBlock(in_channels)
elif attn_type == "none":
return nn.Identity(in_channels)
else:
return LinAttnBlock(in_channels)
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, use_linear_attn=False, attn_type="vanilla"):
super().__init__()
if use_linear_attn: attn_type = "linear"
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(make_attn(block_in, attn_type=attn_type))
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 = make_attn(block_in, attn_type=attn_type)
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(make_attn(block_in, attn_type=attn_type))
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, context=None):
#assert x.shape[2] == x.shape[3] == self.resolution
if context is not None:
# assume aligned context, cat along channel axis
x = torch.cat((x, context), dim=1)
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
def get_last_layer(self):
return self.conv_out.weight
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, use_linear_attn=False, attn_type="vanilla",
**ignore_kwargs):
super().__init__()
if use_linear_attn: attn_type = "linear"
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.in_ch_mult = in_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(make_attn(block_in, attn_type=attn_type))
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 = make_attn(block_in, attn_type=attn_type)
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):
# 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, tanh_out=False, use_linear_attn=False,
attn_type="vanilla", **ignorekwargs):
super().__init__()
if use_linear_attn: attn_type = "linear"
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
self.tanh_out = tanh_out
# 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 = make_attn(block_in, attn_type=attn_type)
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(make_attn(block_in, attn_type=attn_type))
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)
if self.tanh_out:
h = torch.tanh(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
class LatentRescaler(nn.Module):
def __init__(self, factor, in_channels, mid_channels, out_channels, depth=2):
super().__init__()
# residual block, interpolate, residual block
self.factor = factor
self.conv_in = nn.Conv2d(in_channels,
mid_channels,
kernel_size=3,
stride=1,
padding=1)
self.res_block1 = nn.ModuleList([ResnetBlock(in_channels=mid_channels,
out_channels=mid_channels,
temb_channels=0,
dropout=0.0) for _ in range(depth)])
self.attn = AttnBlock(mid_channels)
self.res_block2 = nn.ModuleList([ResnetBlock(in_channels=mid_channels,
out_channels=mid_channels,
temb_channels=0,
dropout=0.0) for _ in range(depth)])
self.conv_out = nn.Conv2d(mid_channels,
out_channels,
kernel_size=1,
)
def forward(self, x):
x = self.conv_in(x)
for block in self.res_block1:
x = block(x, None)
x = torch.nn.functional.interpolate(x, size=(int(round(x.shape[2]*self.factor)), int(round(x.shape[3]*self.factor))))
x = self.attn(x)
for block in self.res_block2:
x = block(x, None)
x = self.conv_out(x)
return x
class MergedRescaleEncoder(nn.Module):
def __init__(self, in_channels, ch, resolution, out_ch, num_res_blocks,
attn_resolutions, dropout=0.0, resamp_with_conv=True,
ch_mult=(1,2,4,8), rescale_factor=1.0, rescale_module_depth=1):
super().__init__()
intermediate_chn = ch * ch_mult[-1]
self.encoder = Encoder(in_channels=in_channels, num_res_blocks=num_res_blocks, ch=ch, ch_mult=ch_mult,
z_channels=intermediate_chn, double_z=False, resolution=resolution,
attn_resolutions=attn_resolutions, dropout=dropout, resamp_with_conv=resamp_with_conv,
out_ch=None)
self.rescaler = LatentRescaler(factor=rescale_factor, in_channels=intermediate_chn,
mid_channels=intermediate_chn, out_channels=out_ch, depth=rescale_module_depth)
def forward(self, x):
x = self.encoder(x)
x = self.rescaler(x)
return x
class MergedRescaleDecoder(nn.Module):
def __init__(self, z_channels, out_ch, resolution, num_res_blocks, attn_resolutions, ch, ch_mult=(1,2,4,8),
dropout=0.0, resamp_with_conv=True, rescale_factor=1.0, rescale_module_depth=1):
super().__init__()
tmp_chn = z_channels*ch_mult[-1]
self.decoder = Decoder(out_ch=out_ch, z_channels=tmp_chn, attn_resolutions=attn_resolutions, dropout=dropout,
resamp_with_conv=resamp_with_conv, in_channels=None, num_res_blocks=num_res_blocks,
ch_mult=ch_mult, resolution=resolution, ch=ch)
self.rescaler = LatentRescaler(factor=rescale_factor, in_channels=z_channels, mid_channels=tmp_chn,
out_channels=tmp_chn, depth=rescale_module_depth)
def forward(self, x):
x = self.rescaler(x)
x = self.decoder(x)
return x
class Upsampler(nn.Module):
def __init__(self, in_size, out_size, in_channels, out_channels, ch_mult=2):
super().__init__()
assert out_size >= in_size
num_blocks = int(np.log2(out_size//in_size))+1
factor_up = 1.+ (out_size % in_size)
print(f"Building {self.__class__.__name__} with in_size: {in_size} --> out_size {out_size} and factor {factor_up}")
self.rescaler = LatentRescaler(factor=factor_up, in_channels=in_channels, mid_channels=2*in_channels,
out_channels=in_channels)
self.decoder = Decoder(out_ch=out_channels, resolution=out_size, z_channels=in_channels, num_res_blocks=2,
attn_resolutions=[], in_channels=None, ch=in_channels,
ch_mult=[ch_mult for _ in range(num_blocks)])
def forward(self, x):
x = self.rescaler(x)
x = self.decoder(x)
return x
class Resize(nn.Module):
def __init__(self, in_channels=None, learned=False, mode="bilinear"):
super().__init__()
self.with_conv = learned
self.mode = mode
if self.with_conv:
print(f"Note: {self.__class__.__name} uses learned downsampling and will ignore the fixed {mode} mode")
raise NotImplementedError()
assert in_channels is not None
# no asymmetric padding in torch conv, must do it ourselves
self.conv = torch.nn.Conv2d(in_channels,
in_channels,
kernel_size=4,
stride=2,
padding=1)
def forward(self, x, scale_factor=1.0):
if scale_factor==1.0:
return x
else:
x = torch.nn.functional.interpolate(x, mode=self.mode, align_corners=False, scale_factor=scale_factor)
return x
class FirstStagePostProcessor(nn.Module):
def __init__(self, ch_mult:list, in_channels,
pretrained_model:nn.Module=None,
reshape=False,
n_channels=None,
dropout=0.,
pretrained_config=None):
super().__init__()
if pretrained_config is None:
assert pretrained_model is not None, 'Either "pretrained_model" or "pretrained_config" must not be None'
self.pretrained_model = pretrained_model
else:
assert pretrained_config is not None, 'Either "pretrained_model" or "pretrained_config" must not be None'
self.instantiate_pretrained(pretrained_config)
self.do_reshape = reshape
if n_channels is None:
n_channels = self.pretrained_model.encoder.ch
self.proj_norm = Normalize(in_channels,num_groups=in_channels//2)
self.proj = nn.Conv2d(in_channels,n_channels,kernel_size=3,
stride=1,padding=1)
blocks = []
downs = []
ch_in = n_channels
for m in ch_mult:
blocks.append(ResnetBlock(in_channels=ch_in,out_channels=m*n_channels,dropout=dropout))
ch_in = m * n_channels
downs.append(Downsample(ch_in, with_conv=False))
self.model = nn.ModuleList(blocks)
self.downsampler = nn.ModuleList(downs)
def instantiate_pretrained(self, config):
model = instantiate_from_config(config)
self.pretrained_model = model.eval()
# self.pretrained_model.train = False
for param in self.pretrained_model.parameters():
param.requires_grad = False
@torch.no_grad()
def encode_with_pretrained(self,x):
c = self.pretrained_model.encode(x)
if isinstance(c, DiagonalGaussianDistribution):
c = c.mode()
return c
def forward(self,x):
z_fs = self.encode_with_pretrained(x)
z = self.proj_norm(z_fs)
z = self.proj(z)
z = nonlinearity(z)
for submodel, downmodel in zip(self.model,self.downsampler):
z = submodel(z,temb=None)
z = downmodel(z)
if self.do_reshape:
z = rearrange(z,'b c h w -> b (h w) c')
return z
| EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/diffusionmodules/model.py |
from abc import abstractmethod
from functools import partial
import math
from typing import Iterable
import numpy as np
import torch as th
import torch.nn as nn
import torch.nn.functional as F
from ldm.modules.diffusionmodules.util import (
checkpoint,
conv_nd,
linear,
avg_pool_nd,
zero_module,
normalization,
timestep_embedding,
)
from ldm.modules.attention import SpatialTransformer
# dummy replace
def convert_module_to_f16(x):
pass
def convert_module_to_f32(x):
pass
## go
class AttentionPool2d(nn.Module):
"""
Adapted from CLIP: https://github.com/openai/CLIP/blob/main/clip/model.py
"""
def __init__(
self,
spacial_dim: int,
embed_dim: int,
num_heads_channels: int,
output_dim: int = None,
):
super().__init__()
self.positional_embedding = nn.Parameter(th.randn(embed_dim, spacial_dim ** 2 + 1) / embed_dim ** 0.5)
self.qkv_proj = conv_nd(1, embed_dim, 3 * embed_dim, 1)
self.c_proj = conv_nd(1, embed_dim, output_dim or embed_dim, 1)
self.num_heads = embed_dim // num_heads_channels
self.attention = QKVAttention(self.num_heads)
def forward(self, x):
b, c, *_spatial = x.shape
x = x.reshape(b, c, -1) # NC(HW)
x = th.cat([x.mean(dim=-1, keepdim=True), x], dim=-1) # NC(HW+1)
x = x + self.positional_embedding[None, :, :].to(x.dtype) # NC(HW+1)
x = self.qkv_proj(x)
x = self.attention(x)
x = self.c_proj(x)
return x[:, :, 0]
class TimestepBlock(nn.Module):
"""
Any module where forward() takes timestep embeddings as a second argument.
"""
@abstractmethod
def forward(self, x, emb):
"""
Apply the module to `x` given `emb` timestep embeddings.
"""
class TimestepEmbedSequential(nn.Sequential, TimestepBlock):
"""
A sequential module that passes timestep embeddings to the children that
support it as an extra input.
"""
def forward(self, x, emb, context=None):
for layer in self:
if isinstance(layer, TimestepBlock):
x = layer(x, emb)
elif isinstance(layer, SpatialTransformer):
x = layer(x, context)
else:
x = layer(x)
return x
class Upsample(nn.Module):
"""
An upsampling layer with an optional convolution.
:param channels: channels in the inputs and outputs.
:param use_conv: a bool determining if a convolution is applied.
:param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
upsampling occurs in the inner-two dimensions.
"""
def __init__(self, channels, use_conv, dims=2, out_channels=None, padding=1):
super().__init__()
self.channels = channels
self.out_channels = out_channels or channels
self.use_conv = use_conv
self.dims = dims
if use_conv:
self.conv = conv_nd(dims, self.channels, self.out_channels, 3, padding=padding)
def forward(self, x):
assert x.shape[1] == self.channels
if self.dims == 3:
x = F.interpolate(
x, (x.shape[2], x.shape[3] * 2, x.shape[4] * 2), mode="nearest"
)
else:
x = F.interpolate(x, scale_factor=2, mode="nearest")
if self.use_conv:
x = self.conv(x)
return x
class TransposedUpsample(nn.Module):
'Learned 2x upsampling without padding'
def __init__(self, channels, out_channels=None, ks=5):
super().__init__()
self.channels = channels
self.out_channels = out_channels or channels
self.up = nn.ConvTranspose2d(self.channels,self.out_channels,kernel_size=ks,stride=2)
def forward(self,x):
return self.up(x)
class Downsample(nn.Module):
"""
A downsampling layer with an optional convolution.
:param channels: channels in the inputs and outputs.
:param use_conv: a bool determining if a convolution is applied.
:param dims: determines if the signal is 1D, 2D, or 3D. If 3D, then
downsampling occurs in the inner-two dimensions.
"""
def __init__(self, channels, use_conv, dims=2, out_channels=None,padding=1):
super().__init__()
self.channels = channels
self.out_channels = out_channels or channels
self.use_conv = use_conv
self.dims = dims
stride = 2 if dims != 3 else (1, 2, 2)
if use_conv:
self.op = conv_nd(
dims, self.channels, self.out_channels, 3, stride=stride, padding=padding
)
else:
assert self.channels == self.out_channels
self.op = avg_pool_nd(dims, kernel_size=stride, stride=stride)
def forward(self, x):
assert x.shape[1] == self.channels
return self.op(x)
class ResBlock(TimestepBlock):
"""
A residual block that can optionally change the number of channels.
:param channels: the number of input channels.
:param emb_channels: the number of timestep embedding channels.
:param dropout: the rate of dropout.
:param out_channels: if specified, the number of out channels.
:param use_conv: if True and out_channels is specified, use a spatial
convolution instead of a smaller 1x1 convolution to change the
channels in the skip connection.
:param dims: determines if the signal is 1D, 2D, or 3D.
:param use_checkpoint: if True, use gradient checkpointing on this module.
:param up: if True, use this block for upsampling.
:param down: if True, use this block for downsampling.
"""
def __init__(
self,
channels,
emb_channels,
dropout,
out_channels=None,
use_conv=False,
use_scale_shift_norm=False,
dims=2,
use_checkpoint=False,
up=False,
down=False,
):
super().__init__()
self.channels = channels
self.emb_channels = emb_channels
self.dropout = dropout
self.out_channels = out_channels or channels
self.use_conv = use_conv
self.use_checkpoint = use_checkpoint
self.use_scale_shift_norm = use_scale_shift_norm
self.in_layers = nn.Sequential(
normalization(channels),
nn.SiLU(),
conv_nd(dims, channels, self.out_channels, 3, padding=1),
)
self.updown = up or down
if up:
self.h_upd = Upsample(channels, False, dims)
self.x_upd = Upsample(channels, False, dims)
elif down:
self.h_upd = Downsample(channels, False, dims)
self.x_upd = Downsample(channels, False, dims)
else:
self.h_upd = self.x_upd = nn.Identity()
self.emb_layers = nn.Sequential(
nn.SiLU(),
linear(
emb_channels,
2 * self.out_channels if use_scale_shift_norm else self.out_channels,
),
)
self.out_layers = nn.Sequential(
normalization(self.out_channels),
nn.SiLU(),
nn.Dropout(p=dropout),
zero_module(
conv_nd(dims, self.out_channels, self.out_channels, 3, padding=1)
),
)
if self.out_channels == channels:
self.skip_connection = nn.Identity()
elif use_conv:
self.skip_connection = conv_nd(
dims, channels, self.out_channels, 3, padding=1
)
else:
self.skip_connection = conv_nd(dims, channels, self.out_channels, 1)
def forward(self, x, emb):
"""
Apply the block to a Tensor, conditioned on a timestep embedding.
:param x: an [N x C x ...] Tensor of features.
:param emb: an [N x emb_channels] Tensor of timestep embeddings.
:return: an [N x C x ...] Tensor of outputs.
"""
return checkpoint(
self._forward, (x, emb), self.parameters(), self.use_checkpoint
)
def _forward(self, x, emb):
if self.updown:
in_rest, in_conv = self.in_layers[:-1], self.in_layers[-1]
h = in_rest(x)
h = self.h_upd(h)
x = self.x_upd(x)
h = in_conv(h)
else:
h = self.in_layers(x)
emb_out = self.emb_layers(emb).type(h.dtype)
while len(emb_out.shape) < len(h.shape):
emb_out = emb_out[..., None]
if self.use_scale_shift_norm:
out_norm, out_rest = self.out_layers[0], self.out_layers[1:]
scale, shift = th.chunk(emb_out, 2, dim=1)
h = out_norm(h) * (1 + scale) + shift
h = out_rest(h)
else:
h = h + emb_out
h = self.out_layers(h)
return self.skip_connection(x) + h
class AttentionBlock(nn.Module):
"""
An attention block that allows spatial positions to attend to each other.
Originally ported from here, but adapted to the N-d case.
https://github.com/hojonathanho/diffusion/blob/1e0dceb3b3495bbe19116a5e1b3596cd0706c543/diffusion_tf/models/unet.py#L66.
"""
def __init__(
self,
channels,
num_heads=1,
num_head_channels=-1,
use_checkpoint=False,
use_new_attention_order=False,
):
super().__init__()
self.channels = channels
if num_head_channels == -1:
self.num_heads = num_heads
else:
assert (
channels % num_head_channels == 0
), f"q,k,v channels {channels} is not divisible by num_head_channels {num_head_channels}"
self.num_heads = channels // num_head_channels
self.use_checkpoint = use_checkpoint
self.norm = normalization(channels)
self.qkv = conv_nd(1, channels, channels * 3, 1)
if use_new_attention_order:
# split qkv before split heads
self.attention = QKVAttention(self.num_heads)
else:
# split heads before split qkv
self.attention = QKVAttentionLegacy(self.num_heads)
self.proj_out = zero_module(conv_nd(1, channels, channels, 1))
def forward(self, x):
return checkpoint(self._forward, (x,), self.parameters(), True) # TODO: check checkpoint usage, is True # TODO: fix the .half call!!!
#return pt_checkpoint(self._forward, x) # pytorch
def _forward(self, x):
b, c, *spatial = x.shape
x = x.reshape(b, c, -1)
qkv = self.qkv(self.norm(x))
h = self.attention(qkv)
h = self.proj_out(h)
return (x + h).reshape(b, c, *spatial)
def count_flops_attn(model, _x, y):
"""
A counter for the `thop` package to count the operations in an
attention operation.
Meant to be used like:
macs, params = thop.profile(
model,
inputs=(inputs, timestamps),
custom_ops={QKVAttention: QKVAttention.count_flops},
)
"""
b, c, *spatial = y[0].shape
num_spatial = int(np.prod(spatial))
# We perform two matmuls with the same number of ops.
# The first computes the weight matrix, the second computes
# the combination of the value vectors.
matmul_ops = 2 * b * (num_spatial ** 2) * c
model.total_ops += th.DoubleTensor([matmul_ops])
class QKVAttentionLegacy(nn.Module):
"""
A module which performs QKV attention. Matches legacy QKVAttention + input/ouput heads shaping
"""
def __init__(self, n_heads):
super().__init__()
self.n_heads = n_heads
def forward(self, qkv):
"""
Apply QKV attention.
:param qkv: an [N x (H * 3 * C) x T] tensor of Qs, Ks, and Vs.
:return: an [N x (H * C) x T] tensor after attention.
"""
bs, width, length = qkv.shape
assert width % (3 * self.n_heads) == 0
ch = width // (3 * self.n_heads)
q, k, v = qkv.reshape(bs * self.n_heads, ch * 3, length).split(ch, dim=1)
scale = 1 / math.sqrt(math.sqrt(ch))
weight = th.einsum(
"bct,bcs->bts", q * scale, k * scale
) # More stable with f16 than dividing afterwards
weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
a = th.einsum("bts,bcs->bct", weight, v)
return a.reshape(bs, -1, length)
@staticmethod
def count_flops(model, _x, y):
return count_flops_attn(model, _x, y)
class QKVAttention(nn.Module):
"""
A module which performs QKV attention and splits in a different order.
"""
def __init__(self, n_heads):
super().__init__()
self.n_heads = n_heads
def forward(self, qkv):
"""
Apply QKV attention.
:param qkv: an [N x (3 * H * C) x T] tensor of Qs, Ks, and Vs.
:return: an [N x (H * C) x T] tensor after attention.
"""
bs, width, length = qkv.shape
assert width % (3 * self.n_heads) == 0
ch = width // (3 * self.n_heads)
q, k, v = qkv.chunk(3, dim=1)
scale = 1 / math.sqrt(math.sqrt(ch))
weight = th.einsum(
"bct,bcs->bts",
(q * scale).view(bs * self.n_heads, ch, length),
(k * scale).view(bs * self.n_heads, ch, length),
) # More stable with f16 than dividing afterwards
weight = th.softmax(weight.float(), dim=-1).type(weight.dtype)
a = th.einsum("bts,bcs->bct", weight, v.reshape(bs * self.n_heads, ch, length))
return a.reshape(bs, -1, length)
@staticmethod
def count_flops(model, _x, y):
return count_flops_attn(model, _x, y)
class UNetModel(nn.Module):
"""
The full UNet model with attention and timestep embedding.
:param in_channels: channels in the input Tensor.
:param model_channels: base channel count for the model.
:param out_channels: channels in the output Tensor.
:param num_res_blocks: number of residual blocks per downsample.
:param attention_resolutions: a collection of downsample rates at which
attention will take place. May be a set, list, or tuple.
For example, if this contains 4, then at 4x downsampling, attention
will be used.
:param dropout: the dropout probability.
:param channel_mult: channel multiplier for each level of the UNet.
:param conv_resample: if True, use learned convolutions for upsampling and
downsampling.
:param dims: determines if the signal is 1D, 2D, or 3D.
:param num_classes: if specified (as an int), then this model will be
class-conditional with `num_classes` classes.
:param use_checkpoint: use gradient checkpointing to reduce memory usage.
:param num_heads: the number of attention heads in each attention layer.
:param num_heads_channels: if specified, ignore num_heads and instead use
a fixed channel width per attention head.
:param num_heads_upsample: works with num_heads to set a different number
of heads for upsampling. Deprecated.
:param use_scale_shift_norm: use a FiLM-like conditioning mechanism.
:param resblock_updown: use residual blocks for up/downsampling.
:param use_new_attention_order: use a different attention pattern for potentially
increased efficiency.
"""
def __init__(
self,
image_size,
in_channels,
model_channels,
out_channels,
num_res_blocks,
attention_resolutions,
dropout=0,
channel_mult=(1, 2, 4, 8),
conv_resample=True,
dims=2,
num_classes=None,
use_checkpoint=False,
use_fp16=False,
num_heads=-1,
num_head_channels=-1,
num_heads_upsample=-1,
use_scale_shift_norm=False,
resblock_updown=False,
use_new_attention_order=False,
use_spatial_transformer=False, # custom transformer support
transformer_depth=1, # custom transformer support
context_dim=None, # custom transformer support
n_embed=None, # custom support for prediction of discrete ids into codebook of first stage vq model
legacy=True,
):
super().__init__()
if use_spatial_transformer:
assert context_dim is not None, 'Fool!! You forgot to include the dimension of your cross-attention conditioning...'
if context_dim is not None:
assert use_spatial_transformer, 'Fool!! You forgot to use the spatial transformer for your cross-attention conditioning...'
from omegaconf.listconfig import ListConfig
if type(context_dim) == ListConfig:
context_dim = list(context_dim)
if num_heads_upsample == -1:
num_heads_upsample = num_heads
if num_heads == -1:
assert num_head_channels != -1, 'Either num_heads or num_head_channels has to be set'
if num_head_channels == -1:
assert num_heads != -1, 'Either num_heads or num_head_channels has to be set'
self.image_size = image_size
self.in_channels = in_channels
self.model_channels = model_channels
self.out_channels = out_channels
self.num_res_blocks = num_res_blocks
self.attention_resolutions = attention_resolutions
self.dropout = dropout
self.channel_mult = channel_mult
self.conv_resample = conv_resample
self.num_classes = num_classes
self.use_checkpoint = use_checkpoint
self.dtype = th.float16 if use_fp16 else th.float32
self.num_heads = num_heads
self.num_head_channels = num_head_channels
self.num_heads_upsample = num_heads_upsample
self.predict_codebook_ids = n_embed is not None
time_embed_dim = model_channels * 4
self.time_embed = nn.Sequential(
linear(model_channels, time_embed_dim),
nn.SiLU(),
linear(time_embed_dim, time_embed_dim),
)
if self.num_classes is not None:
self.label_emb = nn.Embedding(num_classes, time_embed_dim)
self.input_blocks = nn.ModuleList(
[
TimestepEmbedSequential(
conv_nd(dims, in_channels, model_channels, 3, padding=1)
)
]
)
self._feature_size = model_channels
input_block_chans = [model_channels]
ch = model_channels
ds = 1
for level, mult in enumerate(channel_mult):
for _ in range(num_res_blocks):
layers = [
ResBlock(
ch,
time_embed_dim,
dropout,
out_channels=mult * model_channels,
dims=dims,
use_checkpoint=use_checkpoint,
use_scale_shift_norm=use_scale_shift_norm,
)
]
ch = mult * model_channels
if ds in attention_resolutions:
if num_head_channels == -1:
dim_head = ch // num_heads
else:
num_heads = ch // num_head_channels
dim_head = num_head_channels
if legacy:
#num_heads = 1
dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
layers.append(
AttentionBlock(
ch,
use_checkpoint=use_checkpoint,
num_heads=num_heads,
num_head_channels=dim_head,
use_new_attention_order=use_new_attention_order,
) if not use_spatial_transformer else SpatialTransformer(
ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim
)
)
self.input_blocks.append(TimestepEmbedSequential(*layers))
self._feature_size += ch
input_block_chans.append(ch)
if level != len(channel_mult) - 1:
out_ch = ch
self.input_blocks.append(
TimestepEmbedSequential(
ResBlock(
ch,
time_embed_dim,
dropout,
out_channels=out_ch,
dims=dims,
use_checkpoint=use_checkpoint,
use_scale_shift_norm=use_scale_shift_norm,
down=True,
)
if resblock_updown
else Downsample(
ch, conv_resample, dims=dims, out_channels=out_ch
)
)
)
ch = out_ch
input_block_chans.append(ch)
ds *= 2
self._feature_size += ch
if num_head_channels == -1:
dim_head = ch // num_heads
else:
num_heads = ch // num_head_channels
dim_head = num_head_channels
if legacy:
#num_heads = 1
dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
self.middle_block = TimestepEmbedSequential(
ResBlock(
ch,
time_embed_dim,
dropout,
dims=dims,
use_checkpoint=use_checkpoint,
use_scale_shift_norm=use_scale_shift_norm,
),
AttentionBlock(
ch,
use_checkpoint=use_checkpoint,
num_heads=num_heads,
num_head_channels=dim_head,
use_new_attention_order=use_new_attention_order,
) if not use_spatial_transformer else SpatialTransformer(
ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim
),
ResBlock(
ch,
time_embed_dim,
dropout,
dims=dims,
use_checkpoint=use_checkpoint,
use_scale_shift_norm=use_scale_shift_norm,
),
)
self._feature_size += ch
self.output_blocks = nn.ModuleList([])
for level, mult in list(enumerate(channel_mult))[::-1]:
for i in range(num_res_blocks + 1):
ich = input_block_chans.pop()
layers = [
ResBlock(
ch + ich,
time_embed_dim,
dropout,
out_channels=model_channels * mult,
dims=dims,
use_checkpoint=use_checkpoint,
use_scale_shift_norm=use_scale_shift_norm,
)
]
ch = model_channels * mult
if ds in attention_resolutions:
if num_head_channels == -1:
dim_head = ch // num_heads
else:
num_heads = ch // num_head_channels
dim_head = num_head_channels
if legacy:
#num_heads = 1
dim_head = ch // num_heads if use_spatial_transformer else num_head_channels
layers.append(
AttentionBlock(
ch,
use_checkpoint=use_checkpoint,
num_heads=num_heads_upsample,
num_head_channels=dim_head,
use_new_attention_order=use_new_attention_order,
) if not use_spatial_transformer else SpatialTransformer(
ch, num_heads, dim_head, depth=transformer_depth, context_dim=context_dim
)
)
if level and i == num_res_blocks:
out_ch = ch
layers.append(
ResBlock(
ch,
time_embed_dim,
dropout,
out_channels=out_ch,
dims=dims,
use_checkpoint=use_checkpoint,
use_scale_shift_norm=use_scale_shift_norm,
up=True,
)
if resblock_updown
else Upsample(ch, conv_resample, dims=dims, out_channels=out_ch)
)
ds //= 2
self.output_blocks.append(TimestepEmbedSequential(*layers))
self._feature_size += ch
self.out = nn.Sequential(
normalization(ch),
nn.SiLU(),
zero_module(conv_nd(dims, model_channels, out_channels, 3, padding=1)),
)
if self.predict_codebook_ids:
self.id_predictor = nn.Sequential(
normalization(ch),
conv_nd(dims, model_channels, n_embed, 1),
#nn.LogSoftmax(dim=1) # change to cross_entropy and produce non-normalized logits
)
def convert_to_fp16(self):
"""
Convert the torso of the model to float16.
"""
self.input_blocks.apply(convert_module_to_f16)
self.middle_block.apply(convert_module_to_f16)
self.output_blocks.apply(convert_module_to_f16)
def convert_to_fp32(self):
"""
Convert the torso of the model to float32.
"""
self.input_blocks.apply(convert_module_to_f32)
self.middle_block.apply(convert_module_to_f32)
self.output_blocks.apply(convert_module_to_f32)
def forward(self, x, timesteps=None, context=None, y=None,**kwargs):
"""
Apply the model to an input batch.
:param x: an [N x C x ...] Tensor of inputs.
:param timesteps: a 1-D batch of timesteps.
:param context: conditioning plugged in via crossattn
:param y: an [N] Tensor of labels, if class-conditional.
:return: an [N x C x ...] Tensor of outputs.
"""
assert (y is not None) == (
self.num_classes is not None
), "must specify y if and only if the model is class-conditional"
hs = []
t_emb = timestep_embedding(timesteps, self.model_channels, repeat_only=False)
emb = self.time_embed(t_emb)
if self.num_classes is not None:
assert y.shape == (x.shape[0],)
emb = emb + self.label_emb(y)
h = x.type(self.dtype)
for module in self.input_blocks:
h = module(h, emb, context)
hs.append(h)
h = self.middle_block(h, emb, context)
for module in self.output_blocks:
h = th.cat([h, hs.pop()], dim=1)
h = module(h, emb, context)
h = h.type(x.dtype)
if self.predict_codebook_ids:
return self.id_predictor(h)
else:
return self.out(h)
class EncoderUNetModel(nn.Module):
"""
The half UNet model with attention and timestep embedding.
For usage, see UNet.
"""
def __init__(
self,
image_size,
in_channels,
model_channels,
out_channels,
num_res_blocks,
attention_resolutions,
dropout=0,
channel_mult=(1, 2, 4, 8),
conv_resample=True,
dims=2,
use_checkpoint=False,
use_fp16=False,
num_heads=1,
num_head_channels=-1,
num_heads_upsample=-1,
use_scale_shift_norm=False,
resblock_updown=False,
use_new_attention_order=False,
pool="adaptive",
*args,
**kwargs
):
super().__init__()
if num_heads_upsample == -1:
num_heads_upsample = num_heads
self.in_channels = in_channels
self.model_channels = model_channels
self.out_channels = out_channels
self.num_res_blocks = num_res_blocks
self.attention_resolutions = attention_resolutions
self.dropout = dropout
self.channel_mult = channel_mult
self.conv_resample = conv_resample
self.use_checkpoint = use_checkpoint
self.dtype = th.float16 if use_fp16 else th.float32
self.num_heads = num_heads
self.num_head_channels = num_head_channels
self.num_heads_upsample = num_heads_upsample
time_embed_dim = model_channels * 4
self.time_embed = nn.Sequential(
linear(model_channels, time_embed_dim),
nn.SiLU(),
linear(time_embed_dim, time_embed_dim),
)
self.input_blocks = nn.ModuleList(
[
TimestepEmbedSequential(
conv_nd(dims, in_channels, model_channels, 3, padding=1)
)
]
)
self._feature_size = model_channels
input_block_chans = [model_channels]
ch = model_channels
ds = 1
for level, mult in enumerate(channel_mult):
for _ in range(num_res_blocks):
layers = [
ResBlock(
ch,
time_embed_dim,
dropout,
out_channels=mult * model_channels,
dims=dims,
use_checkpoint=use_checkpoint,
use_scale_shift_norm=use_scale_shift_norm,
)
]
ch = mult * model_channels
if ds in attention_resolutions:
layers.append(
AttentionBlock(
ch,
use_checkpoint=use_checkpoint,
num_heads=num_heads,
num_head_channels=num_head_channels,
use_new_attention_order=use_new_attention_order,
)
)
self.input_blocks.append(TimestepEmbedSequential(*layers))
self._feature_size += ch
input_block_chans.append(ch)
if level != len(channel_mult) - 1:
out_ch = ch
self.input_blocks.append(
TimestepEmbedSequential(
ResBlock(
ch,
time_embed_dim,
dropout,
out_channels=out_ch,
dims=dims,
use_checkpoint=use_checkpoint,
use_scale_shift_norm=use_scale_shift_norm,
down=True,
)
if resblock_updown
else Downsample(
ch, conv_resample, dims=dims, out_channels=out_ch
)
)
)
ch = out_ch
input_block_chans.append(ch)
ds *= 2
self._feature_size += ch
self.middle_block = TimestepEmbedSequential(
ResBlock(
ch,
time_embed_dim,
dropout,
dims=dims,
use_checkpoint=use_checkpoint,
use_scale_shift_norm=use_scale_shift_norm,
),
AttentionBlock(
ch,
use_checkpoint=use_checkpoint,
num_heads=num_heads,
num_head_channels=num_head_channels,
use_new_attention_order=use_new_attention_order,
),
ResBlock(
ch,
time_embed_dim,
dropout,
dims=dims,
use_checkpoint=use_checkpoint,
use_scale_shift_norm=use_scale_shift_norm,
),
)
self._feature_size += ch
self.pool = pool
if pool == "adaptive":
self.out = nn.Sequential(
normalization(ch),
nn.SiLU(),
nn.AdaptiveAvgPool2d((1, 1)),
zero_module(conv_nd(dims, ch, out_channels, 1)),
nn.Flatten(),
)
elif pool == "attention":
assert num_head_channels != -1
self.out = nn.Sequential(
normalization(ch),
nn.SiLU(),
AttentionPool2d(
(image_size // ds), ch, num_head_channels, out_channels
),
)
elif pool == "spatial":
self.out = nn.Sequential(
nn.Linear(self._feature_size, 2048),
nn.ReLU(),
nn.Linear(2048, self.out_channels),
)
elif pool == "spatial_v2":
self.out = nn.Sequential(
nn.Linear(self._feature_size, 2048),
normalization(2048),
nn.SiLU(),
nn.Linear(2048, self.out_channels),
)
else:
raise NotImplementedError(f"Unexpected {pool} pooling")
def convert_to_fp16(self):
"""
Convert the torso of the model to float16.
"""
self.input_blocks.apply(convert_module_to_f16)
self.middle_block.apply(convert_module_to_f16)
def convert_to_fp32(self):
"""
Convert the torso of the model to float32.
"""
self.input_blocks.apply(convert_module_to_f32)
self.middle_block.apply(convert_module_to_f32)
def forward(self, x, timesteps):
"""
Apply the model to an input batch.
:param x: an [N x C x ...] Tensor of inputs.
:param timesteps: a 1-D batch of timesteps.
:return: an [N x K] Tensor of outputs.
"""
emb = self.time_embed(timestep_embedding(timesteps, self.model_channels))
results = []
h = x.type(self.dtype)
for module in self.input_blocks:
h = module(h, emb)
if self.pool.startswith("spatial"):
results.append(h.type(x.dtype).mean(dim=(2, 3)))
h = self.middle_block(h, emb)
if self.pool.startswith("spatial"):
results.append(h.type(x.dtype).mean(dim=(2, 3)))
h = th.cat(results, axis=-1)
return self.out(h)
else:
h = h.type(x.dtype)
return self.out(h)
| EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/diffusionmodules/openaimodel.py |
EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/distributions/__init__.py |
|
import torch
import numpy as np
class AbstractDistribution:
def sample(self):
raise NotImplementedError()
def mode(self):
raise NotImplementedError()
class DiracDistribution(AbstractDistribution):
def __init__(self, value):
self.value = value
def sample(self):
return self.value
def mode(self):
return self.value
class DiagonalGaussianDistribution(object):
def __init__(self, parameters, deterministic=False):
self.parameters = parameters
self.mean, self.logvar = torch.chunk(parameters, 2, dim=1)
self.logvar = torch.clamp(self.logvar, -30.0, 20.0)
self.deterministic = deterministic
self.std = torch.exp(0.5 * self.logvar)
self.var = torch.exp(self.logvar)
if self.deterministic:
self.var = self.std = torch.zeros_like(self.mean).to(device=self.parameters.device)
def sample(self):
x = self.mean + self.std * torch.randn(self.mean.shape).to(device=self.parameters.device)
return x
def kl(self, other=None):
if self.deterministic:
return torch.Tensor([0.])
else:
if other is None:
return 0.5 * torch.sum(torch.pow(self.mean, 2)
+ self.var - 1.0 - self.logvar,
dim=[1, 2, 3])
else:
return 0.5 * torch.sum(
torch.pow(self.mean - other.mean, 2) / other.var
+ self.var / other.var - 1.0 - self.logvar + other.logvar,
dim=[1, 2, 3])
def nll(self, sample, dims=[1,2,3]):
if self.deterministic:
return torch.Tensor([0.])
logtwopi = np.log(2.0 * np.pi)
return 0.5 * torch.sum(
logtwopi + self.logvar + torch.pow(sample - self.mean, 2) / self.var,
dim=dims)
def mode(self):
return self.mean
def normal_kl(mean1, logvar1, mean2, logvar2):
"""
source: https://github.com/openai/guided-diffusion/blob/27c20a8fab9cb472df5d6bdd6c8d11c8f430b924/guided_diffusion/losses.py#L12
Compute the KL divergence between two gaussians.
Shapes are automatically broadcasted, so batches can be compared to
scalars, among other use cases.
"""
tensor = None
for obj in (mean1, logvar1, mean2, logvar2):
if isinstance(obj, torch.Tensor):
tensor = obj
break
assert tensor is not None, "at least one argument must be a Tensor"
# Force variances to be Tensors. Broadcasting helps convert scalars to
# Tensors, but it does not work for torch.exp().
logvar1, logvar2 = [
x if isinstance(x, torch.Tensor) else torch.tensor(x).to(tensor)
for x in (logvar1, logvar2)
]
return 0.5 * (
-1.0
+ logvar2
- logvar1
+ torch.exp(logvar1 - logvar2)
+ ((mean1 - mean2) ** 2) * torch.exp(-logvar2)
)
| EXA-1-master | exa/libraries/latent-diffusion/ldm/modules/distributions/distributions.py |
import os
import numpy as np
import PIL
from PIL import Image
from torch.utils.data import Dataset
from torchvision import transforms
class LSUNBase(Dataset):
def __init__(self,
txt_file,
data_root,
size=None,
interpolation="bicubic",
flip_p=0.5
):
self.data_paths = txt_file
self.data_root = data_root
with open(self.data_paths, "r") as f:
self.image_paths = f.read().splitlines()
self._length = len(self.image_paths)
self.labels = {
"relative_file_path_": [l for l in self.image_paths],
"file_path_": [os.path.join(self.data_root, l)
for l in self.image_paths],
}
self.size = size
self.interpolation = {"linear": PIL.Image.LINEAR,
"bilinear": PIL.Image.BILINEAR,
"bicubic": PIL.Image.BICUBIC,
"lanczos": PIL.Image.LANCZOS,
}[interpolation]
self.flip = transforms.RandomHorizontalFlip(p=flip_p)
def __len__(self):
return self._length
def __getitem__(self, i):
example = dict((k, self.labels[k][i]) for k in self.labels)
image = Image.open(example["file_path_"])
if not image.mode == "RGB":
image = image.convert("RGB")
# default to score-sde preprocessing
img = np.array(image).astype(np.uint8)
crop = min(img.shape[0], img.shape[1])
h, w, = img.shape[0], img.shape[1]
img = img[(h - crop) // 2:(h + crop) // 2,
(w - crop) // 2:(w + crop) // 2]
image = Image.fromarray(img)
if self.size is not None:
image = image.resize((self.size, self.size), resample=self.interpolation)
image = self.flip(image)
image = np.array(image).astype(np.uint8)
example["image"] = (image / 127.5 - 1.0).astype(np.float32)
return example
class LSUNChurchesTrain(LSUNBase):
def __init__(self, **kwargs):
super().__init__(txt_file="data/lsun/church_outdoor_train.txt", data_root="data/lsun/churches", **kwargs)
class LSUNChurchesValidation(LSUNBase):
def __init__(self, flip_p=0., **kwargs):
super().__init__(txt_file="data/lsun/church_outdoor_val.txt", data_root="data/lsun/churches",
flip_p=flip_p, **kwargs)
class LSUNBedroomsTrain(LSUNBase):
def __init__(self, **kwargs):
super().__init__(txt_file="data/lsun/bedrooms_train.txt", data_root="data/lsun/bedrooms", **kwargs)
class LSUNBedroomsValidation(LSUNBase):
def __init__(self, flip_p=0.0, **kwargs):
super().__init__(txt_file="data/lsun/bedrooms_val.txt", data_root="data/lsun/bedrooms",
flip_p=flip_p, **kwargs)
class LSUNCatsTrain(LSUNBase):
def __init__(self, **kwargs):
super().__init__(txt_file="data/lsun/cat_train.txt", data_root="data/lsun/cats", **kwargs)
class LSUNCatsValidation(LSUNBase):
def __init__(self, flip_p=0., **kwargs):
super().__init__(txt_file="data/lsun/cat_val.txt", data_root="data/lsun/cats",
flip_p=flip_p, **kwargs)
| EXA-1-master | exa/libraries/latent-diffusion/ldm/data/lsun.py |
import os, yaml, pickle, shutil, tarfile, glob
import cv2
import albumentations
import PIL
import numpy as np
import torchvision.transforms.functional as TF
from omegaconf import OmegaConf
from functools import partial
from PIL import Image
from tqdm import tqdm
from torch.utils.data import Dataset, Subset
import taming.data.utils as tdu
from taming.data.imagenet import str_to_indices, give_synsets_from_indices, download, retrieve
from taming.data.imagenet import ImagePaths
from ldm.modules.image_degradation import degradation_fn_bsr, degradation_fn_bsr_light
def synset2idx(path_to_yaml="data/index_synset.yaml"):
with open(path_to_yaml) as f:
di2s = yaml.load(f)
return dict((v,k) for k,v in di2s.items())
class ImageNetBase(Dataset):
def __init__(self, config=None):
self.config = config or OmegaConf.create()
if not type(self.config)==dict:
self.config = OmegaConf.to_container(self.config)
self.keep_orig_class_label = self.config.get("keep_orig_class_label", False)
self.process_images = True # if False we skip loading & processing images and self.data contains filepaths
self._prepare()
self._prepare_synset_to_human()
self._prepare_idx_to_synset()
self._prepare_human_to_integer_label()
self._load()
def __len__(self):
return len(self.data)
def __getitem__(self, i):
return self.data[i]
def _prepare(self):
raise NotImplementedError()
def _filter_relpaths(self, relpaths):
ignore = set([
"n06596364_9591.JPEG",
])
relpaths = [rpath for rpath in relpaths if not rpath.split("/")[-1] in ignore]
if "sub_indices" in self.config:
indices = str_to_indices(self.config["sub_indices"])
synsets = give_synsets_from_indices(indices, path_to_yaml=self.idx2syn) # returns a list of strings
self.synset2idx = synset2idx(path_to_yaml=self.idx2syn)
files = []
for rpath in relpaths:
syn = rpath.split("/")[0]
if syn in synsets:
files.append(rpath)
return files
else:
return relpaths
def _prepare_synset_to_human(self):
SIZE = 2655750
URL = "https://heibox.uni-heidelberg.de/f/9f28e956cd304264bb82/?dl=1"
self.human_dict = os.path.join(self.root, "synset_human.txt")
if (not os.path.exists(self.human_dict) or
not os.path.getsize(self.human_dict)==SIZE):
download(URL, self.human_dict)
def _prepare_idx_to_synset(self):
URL = "https://heibox.uni-heidelberg.de/f/d835d5b6ceda4d3aa910/?dl=1"
self.idx2syn = os.path.join(self.root, "index_synset.yaml")
if (not os.path.exists(self.idx2syn)):
download(URL, self.idx2syn)
def _prepare_human_to_integer_label(self):
URL = "https://heibox.uni-heidelberg.de/f/2362b797d5be43b883f6/?dl=1"
self.human2integer = os.path.join(self.root, "imagenet1000_clsidx_to_labels.txt")
if (not os.path.exists(self.human2integer)):
download(URL, self.human2integer)
with open(self.human2integer, "r") as f:
lines = f.read().splitlines()
assert len(lines) == 1000
self.human2integer_dict = dict()
for line in lines:
value, key = line.split(":")
self.human2integer_dict[key] = int(value)
def _load(self):
with open(self.txt_filelist, "r") as f:
self.relpaths = f.read().splitlines()
l1 = len(self.relpaths)
self.relpaths = self._filter_relpaths(self.relpaths)
print("Removed {} files from filelist during filtering.".format(l1 - len(self.relpaths)))
self.synsets = [p.split("/")[0] for p in self.relpaths]
self.abspaths = [os.path.join(self.datadir, p) for p in self.relpaths]
unique_synsets = np.unique(self.synsets)
class_dict = dict((synset, i) for i, synset in enumerate(unique_synsets))
if not self.keep_orig_class_label:
self.class_labels = [class_dict[s] for s in self.synsets]
else:
self.class_labels = [self.synset2idx[s] for s in self.synsets]
with open(self.human_dict, "r") as f:
human_dict = f.read().splitlines()
human_dict = dict(line.split(maxsplit=1) for line in human_dict)
self.human_labels = [human_dict[s] for s in self.synsets]
labels = {
"relpath": np.array(self.relpaths),
"synsets": np.array(self.synsets),
"class_label": np.array(self.class_labels),
"human_label": np.array(self.human_labels),
}
if self.process_images:
self.size = retrieve(self.config, "size", default=256)
self.data = ImagePaths(self.abspaths,
labels=labels,
size=self.size,
random_crop=self.random_crop,
)
else:
self.data = self.abspaths
class ImageNetTrain(ImageNetBase):
NAME = "ILSVRC2012_train"
URL = "http://www.image-net.org/challenges/LSVRC/2012/"
AT_HASH = "a306397ccf9c2ead27155983c254227c0fd938e2"
FILES = [
"ILSVRC2012_img_train.tar",
]
SIZES = [
147897477120,
]
def __init__(self, process_images=True, data_root=None, **kwargs):
self.process_images = process_images
self.data_root = data_root
super().__init__(**kwargs)
def _prepare(self):
if self.data_root:
self.root = os.path.join(self.data_root, self.NAME)
else:
cachedir = os.environ.get("XDG_CACHE_HOME", os.path.expanduser("~/.cache"))
self.root = os.path.join(cachedir, "autoencoders/data", self.NAME)
self.datadir = os.path.join(self.root, "data")
self.txt_filelist = os.path.join(self.root, "filelist.txt")
self.expected_length = 1281167
self.random_crop = retrieve(self.config, "ImageNetTrain/random_crop",
default=True)
if not tdu.is_prepared(self.root):
# prep
print("Preparing dataset {} in {}".format(self.NAME, self.root))
datadir = self.datadir
if not os.path.exists(datadir):
path = os.path.join(self.root, self.FILES[0])
if not os.path.exists(path) or not os.path.getsize(path)==self.SIZES[0]:
import academictorrents as at
atpath = at.get(self.AT_HASH, datastore=self.root)
assert atpath == path
print("Extracting {} to {}".format(path, datadir))
os.makedirs(datadir, exist_ok=True)
with tarfile.open(path, "r:") as tar:
tar.extractall(path=datadir)
print("Extracting sub-tars.")
subpaths = sorted(glob.glob(os.path.join(datadir, "*.tar")))
for subpath in tqdm(subpaths):
subdir = subpath[:-len(".tar")]
os.makedirs(subdir, exist_ok=True)
with tarfile.open(subpath, "r:") as tar:
tar.extractall(path=subdir)
filelist = glob.glob(os.path.join(datadir, "**", "*.JPEG"))
filelist = [os.path.relpath(p, start=datadir) for p in filelist]
filelist = sorted(filelist)
filelist = "\n".join(filelist)+"\n"
with open(self.txt_filelist, "w") as f:
f.write(filelist)
tdu.mark_prepared(self.root)
class ImageNetValidation(ImageNetBase):
NAME = "ILSVRC2012_validation"
URL = "http://www.image-net.org/challenges/LSVRC/2012/"
AT_HASH = "5d6d0df7ed81efd49ca99ea4737e0ae5e3a5f2e5"
VS_URL = "https://heibox.uni-heidelberg.de/f/3e0f6e9c624e45f2bd73/?dl=1"
FILES = [
"ILSVRC2012_img_val.tar",
"validation_synset.txt",
]
SIZES = [
6744924160,
1950000,
]
def __init__(self, process_images=True, data_root=None, **kwargs):
self.data_root = data_root
self.process_images = process_images
super().__init__(**kwargs)
def _prepare(self):
if self.data_root:
self.root = os.path.join(self.data_root, self.NAME)
else:
cachedir = os.environ.get("XDG_CACHE_HOME", os.path.expanduser("~/.cache"))
self.root = os.path.join(cachedir, "autoencoders/data", self.NAME)
self.datadir = os.path.join(self.root, "data")
self.txt_filelist = os.path.join(self.root, "filelist.txt")
self.expected_length = 50000
self.random_crop = retrieve(self.config, "ImageNetValidation/random_crop",
default=False)
if not tdu.is_prepared(self.root):
# prep
print("Preparing dataset {} in {}".format(self.NAME, self.root))
datadir = self.datadir
if not os.path.exists(datadir):
path = os.path.join(self.root, self.FILES[0])
if not os.path.exists(path) or not os.path.getsize(path)==self.SIZES[0]:
import academictorrents as at
atpath = at.get(self.AT_HASH, datastore=self.root)
assert atpath == path
print("Extracting {} to {}".format(path, datadir))
os.makedirs(datadir, exist_ok=True)
with tarfile.open(path, "r:") as tar:
tar.extractall(path=datadir)
vspath = os.path.join(self.root, self.FILES[1])
if not os.path.exists(vspath) or not os.path.getsize(vspath)==self.SIZES[1]:
download(self.VS_URL, vspath)
with open(vspath, "r") as f:
synset_dict = f.read().splitlines()
synset_dict = dict(line.split() for line in synset_dict)
print("Reorganizing into synset folders")
synsets = np.unique(list(synset_dict.values()))
for s in synsets:
os.makedirs(os.path.join(datadir, s), exist_ok=True)
for k, v in synset_dict.items():
src = os.path.join(datadir, k)
dst = os.path.join(datadir, v)
shutil.move(src, dst)
filelist = glob.glob(os.path.join(datadir, "**", "*.JPEG"))
filelist = [os.path.relpath(p, start=datadir) for p in filelist]
filelist = sorted(filelist)
filelist = "\n".join(filelist)+"\n"
with open(self.txt_filelist, "w") as f:
f.write(filelist)
tdu.mark_prepared(self.root)
class ImageNetSR(Dataset):
def __init__(self, size=None,
degradation=None, downscale_f=4, min_crop_f=0.5, max_crop_f=1.,
random_crop=True):
"""
Imagenet Superresolution Dataloader
Performs following ops in order:
1. crops a crop of size s from image either as random or center crop
2. resizes crop to size with cv2.area_interpolation
3. degrades resized crop with degradation_fn
:param size: resizing to size after cropping
:param degradation: degradation_fn, e.g. cv_bicubic or bsrgan_light
:param downscale_f: Low Resolution Downsample factor
:param min_crop_f: determines crop size s,
where s = c * min_img_side_len with c sampled from interval (min_crop_f, max_crop_f)
:param max_crop_f: ""
:param data_root:
:param random_crop:
"""
self.base = self.get_base()
assert size
assert (size / downscale_f).is_integer()
self.size = size
self.LR_size = int(size / downscale_f)
self.min_crop_f = min_crop_f
self.max_crop_f = max_crop_f
assert(max_crop_f <= 1.)
self.center_crop = not random_crop
self.image_rescaler = albumentations.SmallestMaxSize(max_size=size, interpolation=cv2.INTER_AREA)
self.pil_interpolation = False # gets reset later if incase interp_op is from pillow
if degradation == "bsrgan":
self.degradation_process = partial(degradation_fn_bsr, sf=downscale_f)
elif degradation == "bsrgan_light":
self.degradation_process = partial(degradation_fn_bsr_light, sf=downscale_f)
else:
interpolation_fn = {
"cv_nearest": cv2.INTER_NEAREST,
"cv_bilinear": cv2.INTER_LINEAR,
"cv_bicubic": cv2.INTER_CUBIC,
"cv_area": cv2.INTER_AREA,
"cv_lanczos": cv2.INTER_LANCZOS4,
"pil_nearest": PIL.Image.NEAREST,
"pil_bilinear": PIL.Image.BILINEAR,
"pil_bicubic": PIL.Image.BICUBIC,
"pil_box": PIL.Image.BOX,
"pil_hamming": PIL.Image.HAMMING,
"pil_lanczos": PIL.Image.LANCZOS,
}[degradation]
self.pil_interpolation = degradation.startswith("pil_")
if self.pil_interpolation:
self.degradation_process = partial(TF.resize, size=self.LR_size, interpolation=interpolation_fn)
else:
self.degradation_process = albumentations.SmallestMaxSize(max_size=self.LR_size,
interpolation=interpolation_fn)
def __len__(self):
return len(self.base)
def __getitem__(self, i):
example = self.base[i]
image = Image.open(example["file_path_"])
if not image.mode == "RGB":
image = image.convert("RGB")
image = np.array(image).astype(np.uint8)
min_side_len = min(image.shape[:2])
crop_side_len = min_side_len * np.random.uniform(self.min_crop_f, self.max_crop_f, size=None)
crop_side_len = int(crop_side_len)
if self.center_crop:
self.cropper = albumentations.CenterCrop(height=crop_side_len, width=crop_side_len)
else:
self.cropper = albumentations.RandomCrop(height=crop_side_len, width=crop_side_len)
image = self.cropper(image=image)["image"]
image = self.image_rescaler(image=image)["image"]
if self.pil_interpolation:
image_pil = PIL.Image.fromarray(image)
LR_image = self.degradation_process(image_pil)
LR_image = np.array(LR_image).astype(np.uint8)
else:
LR_image = self.degradation_process(image=image)["image"]
example["image"] = (image/127.5 - 1.0).astype(np.float32)
example["LR_image"] = (LR_image/127.5 - 1.0).astype(np.float32)
return example
class ImageNetSRTrain(ImageNetSR):
def __init__(self, **kwargs):
super().__init__(**kwargs)
def get_base(self):
with open("data/imagenet_train_hr_indices.p", "rb") as f:
indices = pickle.load(f)
dset = ImageNetTrain(process_images=False,)
return Subset(dset, indices)
class ImageNetSRValidation(ImageNetSR):
def __init__(self, **kwargs):
super().__init__(**kwargs)
def get_base(self):
with open("data/imagenet_val_hr_indices.p", "rb") as f:
indices = pickle.load(f)
dset = ImageNetValidation(process_images=False,)
return Subset(dset, indices)
| EXA-1-master | exa/libraries/latent-diffusion/ldm/data/imagenet.py |
EXA-1-master | exa/libraries/latent-diffusion/ldm/data/__init__.py |
|
from abc import abstractmethod
from torch.utils.data import Dataset, ConcatDataset, ChainDataset, IterableDataset
class Txt2ImgIterableBaseDataset(IterableDataset):
'''
Define an interface to make the IterableDatasets for text2img data chainable
'''
def __init__(self, num_records=0, valid_ids=None, size=256):
super().__init__()
self.num_records = num_records
self.valid_ids = valid_ids
self.sample_ids = valid_ids
self.size = size
print(f'{self.__class__.__name__} dataset contains {self.__len__()} examples.')
def __len__(self):
return self.num_records
@abstractmethod
def __iter__(self):
pass | EXA-1-master | exa/libraries/latent-diffusion/ldm/data/base.py |
#!/usr/bin/env python3
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import os
import subprocess
import sys
from setuptools import Extension, find_packages, setup
from torch.utils import cpp_extension
if sys.version_info < (3, 6):
sys.exit("Sorry, Python >= 3.6 is required for fairseq.")
def write_version_py():
with open(os.path.join("fairseq", "version.txt")) as f:
version = f.read().strip()
# write version info to fairseq/version.py
with open(os.path.join("fairseq", "version.py"), "w") as f:
f.write('__version__ = "{}"\n'.format(version))
return version
version = write_version_py()
with open("README.md") as f:
readme = f.read()
if sys.platform == "darwin":
extra_compile_args = ["-stdlib=libc++", "-O3"]
else:
extra_compile_args = ["-std=c++11", "-O3"]
class NumpyExtension(Extension):
"""Source: https://stackoverflow.com/a/54128391"""
def __init__(self, *args, **kwargs):
self.__include_dirs = []
super().__init__(*args, **kwargs)
@property
def include_dirs(self):
import numpy
return self.__include_dirs + [numpy.get_include()]
@include_dirs.setter
def include_dirs(self, dirs):
self.__include_dirs = dirs
extensions = [
Extension(
"fairseq.libbleu",
sources=[
"fairseq/clib/libbleu/libbleu.cpp",
"fairseq/clib/libbleu/module.cpp",
],
extra_compile_args=extra_compile_args,
),
NumpyExtension(
"fairseq.data.data_utils_fast",
sources=["fairseq/data/data_utils_fast.pyx"],
language="c++",
extra_compile_args=extra_compile_args,
),
NumpyExtension(
"fairseq.data.token_block_utils_fast",
sources=["fairseq/data/token_block_utils_fast.pyx"],
language="c++",
extra_compile_args=extra_compile_args,
),
]
extensions.extend(
[
cpp_extension.CppExtension(
"fairseq.libbase",
sources=[
"fairseq/clib/libbase/balanced_assignment.cpp",
],
),
cpp_extension.CppExtension(
"fairseq.libnat",
sources=[
"fairseq/clib/libnat/edit_dist.cpp",
],
),
cpp_extension.CppExtension(
"alignment_train_cpu_binding",
sources=[
"examples/operators/alignment_train_cpu.cpp",
],
),
]
)
if "CUDA_HOME" in os.environ:
extensions.extend(
[
cpp_extension.CppExtension(
"fairseq.libnat_cuda",
sources=[
"fairseq/clib/libnat_cuda/edit_dist.cu",
"fairseq/clib/libnat_cuda/binding.cpp",
],
),
cpp_extension.CppExtension(
"fairseq.ngram_repeat_block_cuda",
sources=[
"fairseq/clib/cuda/ngram_repeat_block_cuda.cpp",
"fairseq/clib/cuda/ngram_repeat_block_cuda_kernel.cu",
],
),
cpp_extension.CppExtension(
"alignment_train_cuda_binding",
sources=[
"examples/operators/alignment_train_kernel.cu",
"examples/operators/alignment_train_cuda.cpp",
],
),
]
)
cmdclass = {"build_ext": cpp_extension.BuildExtension}
if "READTHEDOCS" in os.environ:
# don't build extensions when generating docs
extensions = []
if "build_ext" in cmdclass:
del cmdclass["build_ext"]
# use CPU build of PyTorch
dependency_links = [
"https://download.pytorch.org/whl/cpu/torch-1.7.0%2Bcpu-cp36-cp36m-linux_x86_64.whl"
]
else:
dependency_links = []
if "clean" in sys.argv[1:]:
# Source: https://bit.ly/2NLVsgE
print("deleting Cython files...")
subprocess.run(
["rm -f fairseq/*.so fairseq/**/*.so fairseq/*.pyd fairseq/**/*.pyd"],
shell=True,
)
extra_packages = []
if os.path.exists(os.path.join("fairseq", "model_parallel", "megatron", "mpu")):
extra_packages.append("fairseq.model_parallel.megatron.mpu")
def do_setup(package_data):
setup(
name="fairseq",
version=version,
description="Facebook AI Research Sequence-to-Sequence Toolkit",
url="https://github.com/pytorch/fairseq",
classifiers=[
"Intended Audience :: Science/Research",
"License :: OSI Approved :: MIT License",
"Programming Language :: Python :: 3.6",
"Programming Language :: Python :: 3.7",
"Programming Language :: Python :: 3.8",
"Topic :: Scientific/Engineering :: Artificial Intelligence",
],
long_description=readme,
long_description_content_type="text/markdown",
install_requires=[
"cffi",
"cython",
"hydra-core>=1.0.7,<1.1",
"omegaconf<2.1",
"numpy>=1.21.3",
"regex",
"sacrebleu>=1.4.12",
"torch>=1.13",
"tqdm",
"bitarray",
"torchaudio>=0.8.0",
"scikit-learn",
"packaging",
],
extras_require={
"dev": ["flake8", "pytest", "black==22.3.0"],
"docs": ["sphinx", "sphinx-argparse"],
},
dependency_links=dependency_links,
packages=find_packages(
exclude=[
"examples",
"examples.*",
"scripts",
"scripts.*",
"tests",
"tests.*",
]
)
+ extra_packages,
package_data=package_data,
ext_modules=extensions,
test_suite="tests",
entry_points={
"console_scripts": [
"fairseq-eval-lm = fairseq_cli.eval_lm:cli_main",
"fairseq-generate = fairseq_cli.generate:cli_main",
"fairseq-hydra-train = fairseq_cli.hydra_train:cli_main",
"fairseq-interactive = fairseq_cli.interactive:cli_main",
"fairseq-preprocess = fairseq_cli.preprocess:cli_main",
"fairseq-score = fairseq_cli.score:cli_main",
"fairseq-train = fairseq_cli.train:cli_main",
"fairseq-validate = fairseq_cli.validate:cli_main",
],
},
cmdclass=cmdclass,
zip_safe=False,
)
def get_files(path, relative_to="fairseq"):
all_files = []
for root, _dirs, files in os.walk(path, followlinks=True):
root = os.path.relpath(root, relative_to)
for file in files:
if file.endswith(".pyc"):
continue
all_files.append(os.path.join(root, file))
return all_files
if __name__ == "__main__":
try:
# symlink examples into fairseq package so package_data accepts them
fairseq_examples = os.path.join("fairseq", "examples")
if "build_ext" not in sys.argv[1:] and not os.path.exists(fairseq_examples):
os.symlink(os.path.join("..", "examples"), fairseq_examples)
package_data = {
"fairseq": (
get_files(fairseq_examples)
+ get_files(os.path.join("fairseq", "config"))
)
}
do_setup(package_data)
finally:
if "build_ext" not in sys.argv[1:] and os.path.islink(fairseq_examples):
os.unlink(fairseq_examples)
| EXA-1-master | exa/libraries/fairseq/setup.py |
#!/usr/bin/env python3 -u
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"""
Legacy entry point. Use fairseq_cli/train.py or fairseq-train instead.
"""
from fairseq_cli.train import cli_main
if __name__ == "__main__":
cli_main()
| EXA-1-master | exa/libraries/fairseq/train.py |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
"""isort:skip_file"""
import functools
import importlib
dependencies = [
"dataclasses",
"hydra",
"numpy",
"omegaconf",
"regex",
"requests",
"torch",
]
# Check for required dependencies and raise a RuntimeError if any are missing.
missing_deps = []
for dep in dependencies:
try:
importlib.import_module(dep)
except ImportError:
# Hack: the hydra package is provided under the "hydra-core" name in
# pypi. We don't want the user mistakenly calling `pip install hydra`
# since that will install an unrelated package.
if dep == "hydra":
dep = "hydra-core"
missing_deps.append(dep)
if len(missing_deps) > 0:
raise RuntimeError("Missing dependencies: {}".format(", ".join(missing_deps)))
# only do fairseq imports after checking for dependencies
from fairseq.hub_utils import ( # noqa; noqa
BPEHubInterface as bpe,
TokenizerHubInterface as tokenizer,
)
from fairseq.models import MODEL_REGISTRY # noqa
# torch.hub doesn't build Cython components, so if they are not found then try
# to build them here
try:
import fairseq.data.token_block_utils_fast # noqa
except ImportError:
try:
import cython # noqa
import os
from setuptools import sandbox
sandbox.run_setup(
os.path.join(os.path.dirname(__file__), "setup.py"),
["build_ext", "--inplace"],
)
except ImportError:
print(
"Unable to build Cython components. Please make sure Cython is "
"installed if the torch.hub model you are loading depends on it."
)
# automatically expose models defined in FairseqModel::hub_models
for _model_type, _cls in MODEL_REGISTRY.items():
for model_name in _cls.hub_models().keys():
globals()[model_name] = functools.partial(
_cls.from_pretrained,
model_name,
)
| EXA-1-master | exa/libraries/fairseq/hubconf.py |
import argparse
from typing import Tuple
def get_next_version(release_type) -> Tuple[Tuple[int, int, int], str, str]:
current_ver = find_version("fairseq/version.txt")
version_list = [int(x) for x in current_ver.strip("'").split(".")]
major, minor, patch = version_list[0], version_list[1], version_list[2]
if release_type == "patch":
patch += 1
elif release_type == "minor":
minor += 1
patch = 0
elif release_type == "major":
major += 1
minor = patch = 0
else:
raise ValueError(
"Incorrect release type specified. Acceptable types are major, minor and patch."
)
new_version_tuple = (major, minor, patch)
new_version_str = ".".join([str(x) for x in new_version_tuple])
new_tag_str = "v" + new_version_str
return new_version_tuple, new_version_str, new_tag_str
def find_version(version_file_path) -> str:
with open(version_file_path) as f:
version = f.read().strip()
return version
def update_version(new_version_str) -> None:
"""
given the current version, update the version to the
next version depending on the type of release.
"""
with open("fairseq/version.txt", "w") as writer:
writer.write(new_version_str)
def main(args):
if args.release_type in ["major", "minor", "patch"]:
new_version_tuple, new_version, new_tag = get_next_version(args.release_type)
else:
raise ValueError("Incorrect release type specified")
if args.update_version:
update_version(new_version)
print(new_version, new_tag)
if __name__ == "__main__":
parser = argparse.ArgumentParser(description="Versioning utils")
parser.add_argument(
"--release-type",
type=str,
required=True,
help="type of release = major/minor/patch",
)
parser.add_argument(
"--update-version",
action="store_true",
required=False,
help="updates the version in fairseq/version.txt",
)
args = parser.parse_args()
main(args)
| EXA-1-master | exa/libraries/fairseq/release_utils.py |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import io
import os
import string
import tempfile
import unittest
import torch
from fairseq import tokenizer
from fairseq.data import Dictionary
class TestDictionary(unittest.TestCase):
def test_finalize(self):
txt = [
"A B C D",
"B C D",
"C D",
"D",
]
ref_ids1 = list(
map(
torch.IntTensor,
[
[4, 5, 6, 7, 2],
[5, 6, 7, 2],
[6, 7, 2],
[7, 2],
],
)
)
ref_ids2 = list(
map(
torch.IntTensor,
[
[7, 6, 5, 4, 2],
[6, 5, 4, 2],
[5, 4, 2],
[4, 2],
],
)
)
# build dictionary
d = Dictionary()
for line in txt:
d.encode_line(line, add_if_not_exist=True)
def get_ids(dictionary):
ids = []
for line in txt:
ids.append(dictionary.encode_line(line, add_if_not_exist=False))
return ids
def assertMatch(ids, ref_ids):
for toks, ref_toks in zip(ids, ref_ids):
self.assertEqual(toks.size(), ref_toks.size())
self.assertEqual(0, (toks != ref_toks).sum().item())
ids = get_ids(d)
assertMatch(ids, ref_ids1)
# check finalized dictionary
d.finalize()
finalized_ids = get_ids(d)
assertMatch(finalized_ids, ref_ids2)
# write to disk and reload
with tempfile.NamedTemporaryFile(mode="w") as tmp_dict:
d.save(tmp_dict.name)
d = Dictionary.load(tmp_dict.name)
reload_ids = get_ids(d)
assertMatch(reload_ids, ref_ids2)
assertMatch(finalized_ids, reload_ids)
def test_overwrite(self):
# for example, Camembert overwrites <unk>, <s> and </s>
dict_file = io.StringIO(
"<unk> 999 #fairseq:overwrite\n"
"<s> 999 #fairseq:overwrite\n"
"</s> 999 #fairseq:overwrite\n"
", 999\n"
"▁de 999\n"
)
d = Dictionary()
d.add_from_file(dict_file)
self.assertEqual(d.index("<pad>"), 1)
self.assertEqual(d.index("foo"), 3)
self.assertEqual(d.index("<unk>"), 4)
self.assertEqual(d.index("<s>"), 5)
self.assertEqual(d.index("</s>"), 6)
self.assertEqual(d.index(","), 7)
self.assertEqual(d.index("▁de"), 8)
def test_no_overwrite(self):
# for example, Camembert overwrites <unk>, <s> and </s>
dict_file = io.StringIO(
"<unk> 999\n" "<s> 999\n" "</s> 999\n" ", 999\n" "▁de 999\n"
)
d = Dictionary()
with self.assertRaisesRegex(RuntimeError, "Duplicate"):
d.add_from_file(dict_file)
def test_space(self):
# for example, character models treat space as a symbol
dict_file = io.StringIO(" 999\n" "a 999\n" "b 999\n")
d = Dictionary()
d.add_from_file(dict_file)
self.assertEqual(d.index(" "), 4)
self.assertEqual(d.index("a"), 5)
self.assertEqual(d.index("b"), 6)
def test_add_file_to_dict(self):
counts = {}
num_lines = 100
per_line = 10
with tempfile.TemporaryDirectory("test_sampling") as data_dir:
filename = os.path.join(data_dir, "dummy.txt")
with open(filename, "w", encoding="utf-8") as data:
for c in string.ascii_letters:
line = f"{c} " * per_line
for _ in range(num_lines):
data.write(f"{line}\n")
counts[c] = per_line * num_lines
per_line += 5
dict = Dictionary()
Dictionary.add_file_to_dictionary(
filename, dict, tokenizer.tokenize_line, 10
)
dict.finalize(threshold=0, nwords=-1, padding_factor=8)
for c in string.ascii_letters:
count = dict.get_count(dict.index(c))
self.assertEqual(
counts[c], count, f"{c} count is {count} but should be {counts[c]}"
)
if __name__ == "__main__":
unittest.main()
| EXA-1-master | exa/libraries/fairseq/tests/test_dictionary.py |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import functools
import unittest
from typing import Any, Dict, Sequence
import fairseq
import fairseq.options
import fairseq.tasks
import torch
from tests.utils import dummy_dictionary
VOCAB_SIZE = 100
@fairseq.tasks.register_task("fake_task")
class FakeTask(fairseq.tasks.LegacyFairseqTask):
def __init__(self, args):
super().__init__(args)
self.dictionary = dummy_dictionary(VOCAB_SIZE - 4)
assert len(self.dictionary) == VOCAB_SIZE
@property
def source_dictionary(self):
return self.dictionary
@property
def target_dictionary(self):
return self.dictionary
@functools.lru_cache()
def get_toy_model(
device: str,
architecture: str = "roberta_enc_dec",
**extra_args: Any,
):
assert device in ("gpu", "cpu")
kwargs = {
"arch": architecture,
# Use characteristics dimensions
"encoder_layers": 3,
"encoder_embed_dim": 12,
"encoder_ffn_embed_dim": 14,
"encoder_attention_heads": 4,
"decoder_layers": 3,
"decoder_embed_dim": 12,
"decoder_ffn_embed_dim": 14,
"decoder_attention_heads": 4,
# Disable dropout so we have comparable tests.
"dropout": 0,
"attention_dropout": 0,
"activation_dropout": 0,
"encoder_layerdrop": 0,
# required args
"tokens_per_sample": 256,
"data": "/tmp/test_roberta",
}
kwargs.update(extra_args)
fake_task = FakeTask(kwargs)
args = fairseq.options.get_args(
task="online_backtranslation",
mono_langs="en,ro",
valid_lang_pairs="en-ro",
**kwargs,
)
torch.manual_seed(0)
model = fake_task.build_model(args)
if device == "gpu":
model.cuda()
return fake_task, model
def mk_sample(
lang: str, device: str, tok: Sequence[int] = None, batch_size: int = 2
) -> Dict[str, Any]:
assert device in ("gpu", "cpu")
if not tok:
if lang == "en":
tok = [10, 11, 12, 13, 14, 15, 2]
else:
tok = [20, 21, 22, 23, 24, 25, 26, 27, 2]
batch = torch.stack([torch.tensor(tok, dtype=torch.long)] * batch_size)
if device == "gpu":
batch = batch.cuda()
sample = {
"net_input": {
"src_tokens": batch,
"prev_output_tokens": batch,
"src_lengths": torch.tensor(
[len(tok)] * batch_size, dtype=torch.long, device=batch.device
),
},
"target": batch[:, 1:],
}
return sample
def cpu_gpu(fn):
def helper(self):
fn(self, "cpu")
if torch.cuda.is_available():
fn(self, "gpu")
return helper
def architectures(fn):
def helper(self):
for arch in ["roberta_enc_dec", "transformer"]:
fn(self, arch)
return helper
class RobertaTest(unittest.TestCase):
def assertTensorEqual(self, t1, t2, delta: float = 1e-6):
self.assertEqual(t1.size(), t2.size(), "size mismatch")
if delta == 0.0:
self.assertEqual(t1.ne(t2).long().sum(), 0)
else:
self.assertEqual(((t2 - t1).abs() > delta).long().sum(), 0)
def assertSharing(self, model, link_groups: Sequence[Sequence[str]]):
ids = {}
for group in link_groups:
group_ids = {name: id(params(model, name)) for name in group}
shared_id = group_ids[group[0]]
self.assertEqual(group_ids, {name: shared_id for name in group})
self.assertNotIn(shared_id, ids)
ids[shared_id] = group
def test_roberta_shared_params(self):
_, roberta = get_toy_model("cpu", architecture="roberta")
self.assertSharing(
roberta,
[
[
"encoder.sentence_encoder.embed_tokens.weight",
"encoder.lm_head.weight",
]
],
)
_, roberta = get_toy_model(
"cpu", architecture="roberta", untie_weights_roberta=True
)
self.assertSharing(
roberta,
[
["encoder.sentence_encoder.embed_tokens.weight"],
["encoder.lm_head.weight"],
],
)
def test_roberta_enc_dec_shared_params(self):
# 3 distinct embeddings
_, enc_dec = get_toy_model("cpu", architecture="roberta_enc_dec")
self.assertSharing(
enc_dec,
[
["encoder.embed_tokens.weight"],
["decoder.embed_tokens.weight"],
["decoder.output_projection.weight"],
],
)
# 2 distinct embeddings, one for encoder, one for decoder
_, enc_dec = get_toy_model(
"cpu", architecture="roberta_enc_dec", share_decoder_input_output_embed=True
)
self.assertSharing(
enc_dec,
[
["encoder.embed_tokens.weight"],
[
"decoder.embed_tokens.weight",
"decoder.output_projection.weight",
],
],
)
# shared embeddings
_, enc_dec = get_toy_model(
"cpu", architecture="roberta_enc_dec", share_all_embeddings=True
)
self.assertSharing(
enc_dec,
[
[
"encoder.embed_tokens.weight",
"decoder.embed_tokens.weight",
"decoder.output_projection.weight",
]
],
)
def test_roberta_max_positions_is_correctly_set(self):
device = "cpu"
task, model = get_toy_model(device)
max_pos = model.max_decoder_positions()
self.assertEqual(max_pos, 256)
self.assertEqual(max_pos, model.decoder.max_positions())
self.assertEqual(max_pos, model.encoder.max_positions())
self.assertEqual(max_pos, model.encoder.embed_positions.max_positions)
sentence = [31 for _ in range(max_pos)]
sample = mk_sample("en", device, sentence, batch_size=1)
self.assertEqual(list(sample["net_input"]["src_lengths"]), [max_pos])
self.assertEqual(len(sample["net_input"]["src_tokens"][0]), max_pos)
x, _ = model.forward(**sample["net_input"])
self.assertEqual(x.shape, (1, max_pos, VOCAB_SIZE))
@cpu_gpu
def test_roberta_forward_backward(self, device: str):
_, model = get_toy_model(device)
sample = mk_sample("en", device)
en_tokens = sample["net_input"]["src_tokens"]
(bs, l) = en_tokens.shape
# Forward
logits, _ = model(**sample["net_input"])
self.assertEqual(logits.shape, (bs, l, VOCAB_SIZE))
# Backward
loss = logits.sum()
loss.backward()
@cpu_gpu
def test_roberta_forward_backward_bs1(self, device: str):
_, model = get_toy_model(device)
sample = mk_sample("en", device, batch_size=1)
o, _ = model.forward(**sample["net_input"])
loss = o.sum()
sample2 = mk_sample("ro", device, batch_size=1)
o, _ = model.forward(**sample2["net_input"])
loss += o.sum()
loss.backward()
@cpu_gpu
def test_roberta_batching(self, device: str):
"""
Checks that the batch of size 2 give twice the same results than the batch of size 1.
"""
_, model = get_toy_model(device)
sample = mk_sample("en", device, batch_size=1)
slen = sample["net_input"]["src_lengths"][0]
sample2 = mk_sample("en", device, batch_size=2)
with torch.no_grad():
z = model.encoder.forward(
sample["net_input"]["src_tokens"], sample["net_input"]["src_lengths"]
)
z = z["encoder_out"][-1]
logits, _ = model.forward(**sample["net_input"])
z2 = model.encoder.forward(
sample2["net_input"]["src_tokens"], sample["net_input"]["src_lengths"]
)
z2 = z2["encoder_out"][-1]
logits2, _ = model.forward(**sample2["net_input"])
self.assertEqual(z.shape, (slen, 1, 12))
self.assertEqual(z2.shape, (slen, 2, 12))
self.assertTensorEqual(logits2[0], logits2[1])
self.assertTensorEqual(logits[0], logits2[0])
@cpu_gpu
def test_roberta_incremental_decoder(self, device: str):
"""
Checks that incremental decoding yields the same result than non incremental one.
"""
task, model = get_toy_model(device)
en_sample = mk_sample("en", device)
en_tokens = en_sample["net_input"]["src_tokens"]
ro_sample = mk_sample("ro", device)
ro_tokens = ro_sample["net_input"]["src_tokens"]
en_enc = model.encoder.forward(
en_tokens, src_lengths=en_sample["net_input"]["src_lengths"]
)
(bs, tgt_len) = ro_tokens.shape
# Decode without incremental state
ro_dec, _ = model.decoder.forward(ro_tokens, encoder_out=en_enc)
self.assertEqual(ro_dec.shape, (bs, tgt_len, VOCAB_SIZE))
self.assertTensorEqual(ro_dec[0], ro_dec[1])
# Decode with incremental state
inc_state = {}
ro_dec_inc = []
for i in range(tgt_len):
ro, _ = model.decoder.forward(
ro_tokens[:, : i + 1], encoder_out=en_enc, incremental_state=inc_state
)
self.assertEqual(ro.shape, (bs, 1, VOCAB_SIZE))
ro_dec_inc.append(ro)
for i in range(tgt_len):
# Intra-batch
self.assertTensorEqual(ro_dec_inc[i][0], ro_dec_inc[i][1])
# Incremental vs non-incremental
self.assertTensorEqual(ro_dec_inc[i][:, 0], ro_dec[:, i])
@cpu_gpu
def test_regularize_for_adaprune_in_roberta(self, device: str):
_, model = get_toy_model(
device=device,
architecture="roberta_base",
mha_reg_scale_factor=0.000375,
ffn_reg_scale_factor=0.000375,
)
sample = mk_sample("en", device, batch_size=1)
task_loss, _ = model.forward(**sample["net_input"])
head_loss = model._get_adaptive_head_loss()
ffn_loss = model._get_adaptive_ffn_loss()
loss = task_loss.sum() + head_loss + ffn_loss
loss.backward()
@cpu_gpu
def test_ffn_prune_for_adaprune_in_roberta(self, device: str):
_, model = get_toy_model(
device=device,
architecture="roberta_base",
)
sample = mk_sample("en", device, batch_size=1)
for layer in model.encoder.sentence_encoder.layers:
fc1_original_size = layer.fc1.out_features
remove_index = layer._get_fc_rank(remove_num=2)
layer._prune_fc_layer(remove_index=remove_index)
self.assertEqual(layer.fc1.out_features, fc1_original_size - 2)
task_loss, _ = model.forward(**sample["net_input"])
def params(model, name):
if "." not in name:
return getattr(model, name)
prefix, name = name.split(".", 1)
return params(getattr(model, prefix), name)
| EXA-1-master | exa/libraries/fairseq/tests/test_roberta.py |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import torch
from fairseq import utils
class TestUtils(unittest.TestCase):
def test_convert_padding_direction(self):
pad = 1
left_pad = torch.LongTensor(
[
[2, 3, 4, 5, 6],
[1, 7, 8, 9, 10],
[1, 1, 1, 11, 12],
]
)
right_pad = torch.LongTensor(
[
[2, 3, 4, 5, 6],
[7, 8, 9, 10, 1],
[11, 12, 1, 1, 1],
]
)
self.assertAlmostEqual(
right_pad,
utils.convert_padding_direction(
left_pad,
pad,
left_to_right=True,
),
)
self.assertAlmostEqual(
left_pad,
utils.convert_padding_direction(
right_pad,
pad,
right_to_left=True,
),
)
def test_make_positions(self):
pad = 1
left_pad_input = torch.LongTensor(
[
[9, 9, 9, 9, 9],
[1, 9, 9, 9, 9],
[1, 1, 1, 9, 9],
]
)
left_pad_output = torch.LongTensor(
[
[2, 3, 4, 5, 6],
[1, 2, 3, 4, 5],
[1, 1, 1, 2, 3],
]
)
right_pad_input = torch.LongTensor(
[
[9, 9, 9, 9, 9],
[9, 9, 9, 9, 1],
[9, 9, 1, 1, 1],
]
)
right_pad_output = torch.LongTensor(
[
[2, 3, 4, 5, 6],
[2, 3, 4, 5, 1],
[2, 3, 1, 1, 1],
]
)
self.assertAlmostEqual(
left_pad_output,
utils.make_positions(left_pad_input, pad),
)
self.assertAlmostEqual(
right_pad_output,
utils.make_positions(right_pad_input, pad),
)
def test_clip_grad_norm_(self):
params = torch.nn.Parameter(torch.zeros(5)).requires_grad_(False)
grad_norm = utils.clip_grad_norm_(params, 1.0)
self.assertTrue(torch.is_tensor(grad_norm))
self.assertEqual(grad_norm, 0.0)
params = [torch.nn.Parameter(torch.zeros(5)) for i in range(3)]
for p in params:
p.grad = torch.full((5,), fill_value=2.0)
grad_norm = utils.clip_grad_norm_(params, 1.0)
exp_grad_norm = torch.full((15,), fill_value=2.0).norm()
self.assertTrue(torch.is_tensor(grad_norm))
self.assertEqual(grad_norm, exp_grad_norm)
grad_norm = utils.clip_grad_norm_(params, 1.0)
self.assertAlmostEqual(grad_norm, torch.tensor(1.0))
def test_resolve_max_positions_with_tuple(self):
resolved = utils.resolve_max_positions(None, (2000, 100, 2000), 12000)
self.assertEqual(resolved, (2000, 100, 2000))
def assertAlmostEqual(self, t1, t2):
self.assertEqual(t1.size(), t2.size(), "size mismatch")
self.assertLess(utils.item((t1 - t2).abs().max()), 1e-4)
if __name__ == "__main__":
unittest.main()
| EXA-1-master | exa/libraries/fairseq/tests/test_utils.py |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
from copy import deepcopy
from dataclasses import dataclass
import pytest
from typing import Optional
from unittest.mock import patch
import torch
from fairseq.models.ema import EMA
class DummyModule(torch.nn.Module):
def __init__(self) -> None:
"""LightningModule for testing purposes
Args:
epoch_min_loss_override (int, optional): Pass in an epoch that will be set to the minimum
validation loss for testing purposes (zero based). If None this is ignored. Defaults to None.
"""
super().__init__()
self.layer = torch.nn.Linear(in_features=32, out_features=2)
self.another_layer = torch.nn.Linear(in_features=2, out_features=2)
def forward(self, x: torch.Tensor) -> torch.Tensor:
x = self.layer(x)
return self.another_layer(x)
@dataclass
class EMAConfig(object):
ema_decay: float = 0.99
ema_start_update: int = 0
ema_fp32: bool = False
ema_seed_model: Optional[str] = None
ema_update_freq: int = 1
class TestEMA(unittest.TestCase):
def assertTorchAllClose(self, x, y, atol=1e-8, rtol=1e-5, msg=None):
diff = x.float() - y.float()
diff_norm = torch.norm(diff)
other_norm = torch.norm(y.float())
if msg is None:
msg = "|input - other| > {} + {} * |other|".format(atol, rtol)
self.assertLessEqual(
diff_norm,
atol + rtol * other_norm,
msg=msg,
)
def test_ema(self):
model = DummyModule()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
state = deepcopy(model.state_dict())
config = EMAConfig()
ema = EMA(model, config)
# set decay
ema._set_decay(config.ema_decay)
self.assertEqual(ema.get_decay(), config.ema_decay)
# get model
self.assertEqual(ema.get_model(), ema.model)
# Since fp32 params is not used, it should be of size 0
self.assertEqual(len(ema.fp32_params), 0)
# EMA step
x = torch.randn(32)
y = model(x)
loss = y.sum()
loss.backward()
optimizer.step()
ema.step(model)
ema_state_dict = ema.get_model().state_dict()
for key, param in model.state_dict().items():
prev_param = state[key]
ema_param = ema_state_dict[key]
if "version" in key:
# Do not decay a model.version pytorch param
continue
self.assertTorchAllClose(
ema_param,
config.ema_decay * prev_param + (1 - config.ema_decay) * param,
)
# Since fp32 params is not used, it should be of size 0
self.assertEqual(len(ema.fp32_params), 0)
# Load EMA into model
model2 = DummyModule()
ema.reverse(model2)
for key, param in model2.state_dict().items():
ema_param = ema_state_dict[key]
self.assertTrue(torch.allclose(ema_param, param))
# Check that step_internal is called once
with patch.object(ema, "_step_internal", return_value=None) as mock_method:
ema.step(model)
mock_method.assert_called_once_with(model, None)
def _test_ema_start_update(self, updates):
model = DummyModule()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
state = deepcopy(model.state_dict())
config = EMAConfig(ema_start_update=1)
ema = EMA(model, config)
# EMA step
x = torch.randn(32)
y = model(x)
loss = y.sum()
loss.backward()
optimizer.step()
ema.step(model, updates=updates)
ema_state_dict = ema.get_model().state_dict()
self.assertEqual(ema.get_decay(), 0 if updates == 0 else config.ema_decay)
for key, param in model.state_dict().items():
ema_param = ema_state_dict[key]
prev_param = state[key]
if "version" in key:
# Do not decay a model.version pytorch param
continue
if updates == 0:
self.assertTorchAllClose(
ema_param,
param,
)
else:
self.assertTorchAllClose(
ema_param,
config.ema_decay * prev_param + (1 - config.ema_decay) * param,
)
# Check that step_internal is called once
with patch.object(ema, "_step_internal", return_value=None) as mock_method:
ema.step(model, updates=updates)
mock_method.assert_called_once_with(model, updates)
def test_ema_before_start_update(self):
self._test_ema_start_update(updates=0)
def test_ema_after_start_update(self):
self._test_ema_start_update(updates=1)
def test_ema_fp32(self):
dtype = torch.float
model = DummyModule().to(dtype)
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
state = deepcopy(model.state_dict())
config = EMAConfig(ema_fp32=True)
ema = EMA(model, config)
x = torch.randn(32)
y = model(x.to(dtype))
loss = y.sum()
loss.backward()
optimizer.step()
ema.step(model)
for key, param in model.state_dict().items():
prev_param = state[key]
ema_param = ema.get_model().state_dict()[key]
if "version" in key:
# Do not decay a model.version pytorch param
continue
self.assertIn(key, ema.fp32_params)
# EMA update is done in fp32, and hence the EMA param must be
# closer to the EMA update done in fp32 than in fp16.
self.assertLessEqual(
torch.norm(
ema_param.float()
- (
config.ema_decay * prev_param.float()
+ (1 - config.ema_decay) * param.float()
)
.to(dtype)
.float()
),
torch.norm(
ema_param.float()
- (
config.ema_decay * prev_param + (1 - config.ema_decay) * param
).float()
),
)
self.assertTorchAllClose(
ema_param,
(
config.ema_decay * prev_param.float()
+ (1 - config.ema_decay) * param.float()
).to(dtype),
)
@pytest.mark.skipif(
not torch.cuda.is_available(),
reason="CPU no longer supports Linear in half precision",
)
def test_ema_fp16(self):
model = DummyModule().cuda().half()
optimizer = torch.optim.SGD(model.parameters(), lr=0.01)
state = deepcopy(model.state_dict())
config = EMAConfig(ema_fp32=False)
ema = EMA(model, config)
# Since fp32 params is not used, it should be of size 0
self.assertEqual(len(ema.fp32_params), 0)
x = torch.randn(32).cuda()
y = model(x.half())
loss = y.sum()
loss.backward()
optimizer.step()
ema.step(model)
for key, param in model.state_dict().items():
prev_param = state[key]
ema_param = ema.get_model().state_dict()[key]
if "version" in key:
# Do not decay a model.version pytorch param
continue
# EMA update is done in fp16, and hence the EMA param must be
# closer to the EMA update done in fp16 than in fp32.
self.assertLessEqual(
torch.norm(
ema_param.float()
- (
config.ema_decay * prev_param + (1 - config.ema_decay) * param
).float()
),
torch.norm(
ema_param.float()
- (
config.ema_decay * prev_param.float()
+ (1 - config.ema_decay) * param.float()
)
.half()
.float()
),
)
self.assertTorchAllClose(
ema_param,
config.ema_decay * prev_param + (1 - config.ema_decay) * param,
)
# Since fp32 params is not used, it should be of size 0
self.assertEqual(len(ema.fp32_params), 0)
if __name__ == "__main__":
unittest.main()
| EXA-1-master | exa/libraries/fairseq/tests/test_ema.py |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
from fairseq.data import iterators, ListDataset
class TestIterators(unittest.TestCase):
def test_counting_iterator_index(self, ref=None, itr=None):
# Test the indexing functionality of CountingIterator
if ref is None:
assert itr is None
ref = list(range(10))
itr = iterators.CountingIterator(ref)
else:
assert len(ref) == 10
assert itr is not None
self.assertTrue(itr.has_next())
self.assertEqual(itr.n, 0)
self.assertEqual(next(itr), ref[0])
self.assertEqual(itr.n, 1)
self.assertEqual(next(itr), ref[1])
self.assertEqual(itr.n, 2)
itr.skip(3)
self.assertEqual(itr.n, 5)
self.assertEqual(next(itr), ref[5])
itr.skip(2)
self.assertEqual(itr.n, 8)
self.assertEqual(list(itr), [ref[8], ref[9]])
self.assertFalse(itr.has_next())
def test_counting_iterator_length_mismatch(self):
ref = list(range(10))
# When the underlying iterable is longer than the CountingIterator,
# the remaining items in the iterable should be ignored
itr = iterators.CountingIterator(ref, total=8)
self.assertEqual(list(itr), ref[:8])
# When the underlying iterable is shorter than the CountingIterator,
# raise an IndexError when the underlying iterable is exhausted
itr = iterators.CountingIterator(ref, total=12)
self.assertRaises(IndexError, list, itr)
def test_counting_iterator_take(self):
# Test the "take" method of CountingIterator
ref = list(range(10))
itr = iterators.CountingIterator(ref)
itr.take(5)
self.assertEqual(len(itr), len(list(iter(itr))))
self.assertEqual(len(itr), 5)
itr = iterators.CountingIterator(ref)
itr.take(5)
self.assertEqual(next(itr), ref[0])
self.assertEqual(next(itr), ref[1])
itr.skip(2)
self.assertEqual(next(itr), ref[4])
self.assertFalse(itr.has_next())
def test_grouped_iterator(self):
# test correctness
x = list(range(10))
itr = iterators.GroupedIterator(x, 1)
self.assertEqual(list(itr), [[0], [1], [2], [3], [4], [5], [6], [7], [8], [9]])
itr = iterators.GroupedIterator(x, 4)
self.assertEqual(list(itr), [[0, 1, 2, 3], [4, 5, 6, 7], [8, 9]])
itr = iterators.GroupedIterator(x, 5)
self.assertEqual(list(itr), [[0, 1, 2, 3, 4], [5, 6, 7, 8, 9]])
# test the GroupIterator also works correctly as a CountingIterator
x = list(range(30))
ref = list(iterators.GroupedIterator(x, 3))
itr = iterators.GroupedIterator(x, 3)
self.test_counting_iterator_index(ref, itr)
def test_sharded_iterator(self):
# test correctness
x = list(range(10))
itr = iterators.ShardedIterator(x, num_shards=1, shard_id=0)
self.assertEqual(list(itr), x)
itr = iterators.ShardedIterator(x, num_shards=2, shard_id=0)
self.assertEqual(list(itr), [0, 2, 4, 6, 8])
itr = iterators.ShardedIterator(x, num_shards=2, shard_id=1)
self.assertEqual(list(itr), [1, 3, 5, 7, 9])
itr = iterators.ShardedIterator(x, num_shards=3, shard_id=0)
self.assertEqual(list(itr), [0, 3, 6, 9])
itr = iterators.ShardedIterator(x, num_shards=3, shard_id=1)
self.assertEqual(list(itr), [1, 4, 7, None])
itr = iterators.ShardedIterator(x, num_shards=3, shard_id=2)
self.assertEqual(list(itr), [2, 5, 8, None])
# test CountingIterator functionality
x = list(range(30))
ref = list(iterators.ShardedIterator(x, num_shards=3, shard_id=0))
itr = iterators.ShardedIterator(x, num_shards=3, shard_id=0)
self.test_counting_iterator_index(ref, itr)
def test_counting_iterator_buffered_iterator_take(self):
ref = list(range(10))
buffered_itr = iterators.BufferedIterator(2, ref)
itr = iterators.CountingIterator(buffered_itr)
itr.take(5)
self.assertEqual(len(itr), len(list(iter(itr))))
self.assertEqual(len(itr), 5)
buffered_itr = iterators.BufferedIterator(2, ref)
itr = iterators.CountingIterator(buffered_itr)
itr.take(5)
self.assertEqual(len(buffered_itr), 5)
self.assertEqual(len(list(iter(buffered_itr))), 5)
buffered_itr = iterators.BufferedIterator(2, ref)
itr = iterators.CountingIterator(buffered_itr)
itr.take(5)
self.assertEqual(next(itr), ref[0])
self.assertEqual(next(itr), ref[1])
itr.skip(2)
self.assertEqual(next(itr), ref[4])
self.assertFalse(itr.has_next())
self.assertRaises(StopIteration, next, buffered_itr)
ref = list(range(4, 10))
buffered_itr = iterators.BufferedIterator(2, ref)
itr = iterators.CountingIterator(buffered_itr, start=4)
itr.take(5)
self.assertEqual(len(itr), 5)
self.assertEqual(len(buffered_itr), 1)
self.assertEqual(next(itr), ref[0])
self.assertFalse(itr.has_next())
self.assertRaises(StopIteration, next, buffered_itr)
def test_epoch_batch_iterator_skip_remainder_batch(self):
reference = [1, 2, 3]
itr1 = _get_epoch_batch_itr(reference, 2, True)
self.assertEqual(len(itr1), 1)
itr2 = _get_epoch_batch_itr(reference, 2, False)
self.assertEqual(len(itr2), 2)
itr3 = _get_epoch_batch_itr(reference, 1, True)
self.assertEqual(len(itr3), 2)
itr4 = _get_epoch_batch_itr(reference, 1, False)
self.assertEqual(len(itr4), 3)
itr5 = _get_epoch_batch_itr(reference, 4, True)
self.assertEqual(len(itr5), 0)
self.assertFalse(itr5.has_next())
itr6 = _get_epoch_batch_itr(reference, 4, False)
self.assertEqual(len(itr6), 1)
def test_grouped_iterator_skip_remainder_batch(self):
reference = [1, 2, 3, 4, 5, 6, 7, 8, 9]
itr1 = _get_epoch_batch_itr(reference, 3, False)
grouped_itr1 = iterators.GroupedIterator(itr1, 2, True)
self.assertEqual(len(grouped_itr1), 1)
itr2 = _get_epoch_batch_itr(reference, 3, False)
grouped_itr2 = iterators.GroupedIterator(itr2, 2, False)
self.assertEqual(len(grouped_itr2), 2)
itr3 = _get_epoch_batch_itr(reference, 3, True)
grouped_itr3 = iterators.GroupedIterator(itr3, 2, True)
self.assertEqual(len(grouped_itr3), 1)
itr4 = _get_epoch_batch_itr(reference, 3, True)
grouped_itr4 = iterators.GroupedIterator(itr4, 2, False)
self.assertEqual(len(grouped_itr4), 1)
itr5 = _get_epoch_batch_itr(reference, 5, True)
grouped_itr5 = iterators.GroupedIterator(itr5, 2, True)
self.assertEqual(len(grouped_itr5), 0)
itr6 = _get_epoch_batch_itr(reference, 5, True)
grouped_itr6 = iterators.GroupedIterator(itr6, 2, False)
self.assertEqual(len(grouped_itr6), 1)
def _get_epoch_batch_itr(ref, bsz, skip_remainder_batch):
dsz = len(ref)
indices = range(dsz)
starts = indices[::bsz]
batch_sampler = [indices[s : s + bsz] for s in starts]
dataset = ListDataset(ref)
itr = iterators.EpochBatchIterator(
dataset=dataset,
collate_fn=dataset.collater,
batch_sampler=batch_sampler,
skip_remainder_batch=skip_remainder_batch,
)
return itr.next_epoch_itr()
if __name__ == "__main__":
unittest.main()
| EXA-1-master | exa/libraries/fairseq/tests/test_iterators.py |
import torch
import numpy as np
import unittest
from fairseq.modules import (
ESPNETMultiHeadedAttention,
RelPositionMultiHeadedAttention,
RotaryPositionMultiHeadedAttention,
)
torch.use_deterministic_algorithms(True)
class TestESPNETMultiHeadedAttention(unittest.TestCase):
def setUp(self) -> None:
self.T = 3
self.B = 1
self.C = 2
torch.manual_seed(0)
self.sample = torch.randn(self.T, self.B, self.C) # TBC
self.sample_scores = torch.randn(self.B, 1, self.T, self.T)
self.MHA = ESPNETMultiHeadedAttention(self.C, 1, dropout=0)
def test_forward(self):
expected_scores = torch.tensor(
[[[0.1713, -0.3776]], [[0.2263, -0.4486]], [[0.2243, -0.4538]]]
)
scores, _ = self.MHA(self.sample, self.sample, self.sample)
self.assertTrue(
np.allclose(
expected_scores.cpu().detach().numpy(),
scores.cpu().detach().numpy(),
atol=1e-4,
)
)
def test_forward_qkv(self):
expected_query = torch.tensor(
[[[[-1.0235, 0.0409], [0.4008, 1.3077], [0.5396, 2.0698]]]]
)
expected_key = torch.tensor(
[[[[0.5053, -0.4965], [-0.3730, -0.9473], [-0.7019, -0.1935]]]]
)
expected_val = torch.tensor(
[[[[-0.9940, 0.5403], [0.5924, -0.7619], [0.7504, -1.0892]]]]
)
sample_t = self.sample.transpose(0, 1)
query, key, val = self.MHA.forward_qkv(sample_t, sample_t, sample_t)
self.assertTrue(
np.allclose(
expected_query.cpu().detach().numpy(),
query.cpu().detach().numpy(),
atol=1e-4,
)
)
self.assertTrue(
np.allclose(
expected_key.cpu().detach().numpy(),
key.cpu().detach().numpy(),
atol=1e-4,
)
)
self.assertTrue(
np.allclose(
expected_val.cpu().detach().numpy(),
val.cpu().detach().numpy(),
atol=1e-4,
)
)
def test_forward_attention(self):
expected_scores = torch.tensor(
[[[0.1627, -0.6249], [-0.2547, -0.6487], [-0.0711, -0.8545]]]
)
scores = self.MHA.forward_attention(
self.sample.transpose(0, 1).view(self.B, 1, self.T, self.C),
self.sample_scores,
mask=None,
)
self.assertTrue(
np.allclose(
expected_scores.cpu().detach().numpy(),
scores.cpu().detach().numpy(),
atol=1e-4,
)
)
class TestRelPositionMultiHeadedAttention(unittest.TestCase):
def setUp(self) -> None:
self.T = 3
self.B = 1
self.C = 2
torch.manual_seed(0)
self.sample = torch.randn(self.T, self.B, self.C) # TBC
self.sample_x = torch.randn(self.B, 1, self.T, self.T * 2 - 1)
self.sample_pos = torch.randn(self.B, self.T * 2 - 1, self.C)
self.MHA = RelPositionMultiHeadedAttention(self.C, 1, dropout=0)
def test_rel_shift(self):
expected_x = torch.tensor(
[
[
[
[-0.7193, -0.4033, -0.5966],
[-0.8567, 1.1006, -1.0712],
[-0.5663, 0.3731, -0.8920],
]
]
]
)
x = self.MHA.rel_shift(self.sample_x)
self.assertTrue(
np.allclose(
expected_x.cpu().detach().numpy(),
x.cpu().detach().numpy(),
atol=1e-4,
)
)
def test_forward(self):
expected_scores = torch.tensor(
[
[[-0.9609, -0.5020]],
[[-0.9308, -0.4890]],
[[-0.9473, -0.4948]],
[[-0.9609, -0.5020]],
[[-0.9308, -0.4890]],
[[-0.9473, -0.4948]],
[[-0.9609, -0.5020]],
[[-0.9308, -0.4890]],
[[-0.9473, -0.4948]],
[[-0.9609, -0.5020]],
[[-0.9308, -0.4890]],
[[-0.9473, -0.4948]],
[[-0.9609, -0.5020]],
[[-0.9308, -0.4890]],
[[-0.9473, -0.4948]],
]
)
scores, _ = self.MHA(self.sample, self.sample, self.sample, self.sample_pos)
self.assertTrue(
np.allclose(
expected_scores.cpu().detach().numpy(),
scores.cpu().detach().numpy(),
atol=1e-4,
)
)
class TestRotaryPositionMultiHeadedAttention(unittest.TestCase):
def setUp(self) -> None:
self.T = 3
self.B = 1
self.C = 2
torch.manual_seed(0)
self.sample = torch.randn(self.T, self.B, self.C) # TBC
self.MHA = RotaryPositionMultiHeadedAttention(
self.C, 1, dropout=0, precision=None
)
def test_forward(self):
expected_scores = torch.tensor(
[[[-0.3220, -0.4726]], [[-1.2813, -0.0979]], [[-0.3138, -0.4758]]]
)
scores, _ = self.MHA(self.sample, self.sample, self.sample)
self.assertTrue(
np.allclose(
expected_scores.cpu().detach().numpy(),
scores.cpu().detach().numpy(),
atol=1e-4,
)
)
if __name__ == "__main__":
unittest.main()
| EXA-1-master | exa/libraries/fairseq/tests/test_espnet_multihead_attention.py |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
from typing import Dict, List
import torch
import tests.utils as test_utils
from fairseq import utils
from fairseq.data import (
Dictionary,
LanguagePairDataset,
TransformEosDataset,
data_utils,
noising,
)
class TestDataNoising(unittest.TestCase):
def _get_test_data_with_bpe_cont_marker(self, append_eos=True):
"""
Args:
append_eos: if True, each input sentence in the source tokens tensor
will have an EOS appended to the end.
Returns:
vocabs: BPE vocab with continuation markers as suffixes to denote
non-end of word tokens. This is the standard BPE format used in
fairseq's preprocessing.
x: input tensor containing numberized source tokens, with EOS at the
end if append_eos is true
src_lengths: and source lengths.
"""
vocab = Dictionary()
vocab.add_symbol("he@@")
vocab.add_symbol("llo")
vocab.add_symbol("how")
vocab.add_symbol("are")
vocab.add_symbol("y@@")
vocab.add_symbol("ou")
vocab.add_symbol("n@@")
vocab.add_symbol("ew")
vocab.add_symbol("or@@")
vocab.add_symbol("k")
src_tokens = [
["he@@", "llo", "n@@", "ew", "y@@", "or@@", "k"],
["how", "are", "y@@", "ou"],
]
x, src_lengths = x, src_lengths = self._convert_src_tokens_to_tensor(
vocab=vocab, src_tokens=src_tokens, append_eos=append_eos
)
return vocab, x, src_lengths
def _get_test_data_with_bpe_end_marker(self, append_eos=True):
"""
Args:
append_eos: if True, each input sentence in the source tokens tensor
will have an EOS appended to the end.
Returns:
vocabs: BPE vocab with end-of-word markers as suffixes to denote
tokens at the end of a word. This is an alternative to fairseq's
standard preprocessing framework and is not generally supported
within fairseq.
x: input tensor containing numberized source tokens, with EOS at the
end if append_eos is true
src_lengths: and source lengths.
"""
vocab = Dictionary()
vocab.add_symbol("he")
vocab.add_symbol("llo_EOW")
vocab.add_symbol("how_EOW")
vocab.add_symbol("are_EOW")
vocab.add_symbol("y")
vocab.add_symbol("ou_EOW")
vocab.add_symbol("n")
vocab.add_symbol("ew_EOW")
vocab.add_symbol("or")
vocab.add_symbol("k_EOW")
src_tokens = [
["he", "llo_EOW", "n", "ew_EOW", "y", "or", "k_EOW"],
["how_EOW", "are_EOW", "y", "ou_EOW"],
]
x, src_lengths = x, src_lengths = self._convert_src_tokens_to_tensor(
vocab=vocab, src_tokens=src_tokens, append_eos=append_eos
)
return vocab, x, src_lengths
def _get_test_data_with_word_vocab(self, append_eos=True):
"""
Args:
append_eos: if True, each input sentence in the source tokens tensor
will have an EOS appended to the end.
Returns:
vocabs: word vocab
x: input tensor containing numberized source tokens, with EOS at the
end if append_eos is true
src_lengths: and source lengths.
"""
vocab = Dictionary()
vocab.add_symbol("hello")
vocab.add_symbol("how")
vocab.add_symbol("are")
vocab.add_symbol("you")
vocab.add_symbol("new")
vocab.add_symbol("york")
src_tokens = [
["hello", "new", "york", "you"],
["how", "are", "you", "new", "york"],
]
x, src_lengths = self._convert_src_tokens_to_tensor(
vocab=vocab, src_tokens=src_tokens, append_eos=append_eos
)
return vocab, x, src_lengths
def _convert_src_tokens_to_tensor(
self, vocab: Dictionary, src_tokens: List[List[str]], append_eos: bool
):
src_len = [len(x) for x in src_tokens]
# If we have to append EOS, we include EOS in counting src length
if append_eos:
src_len = [length + 1 for length in src_len]
x = torch.LongTensor(len(src_tokens), max(src_len)).fill_(vocab.pad())
for i in range(len(src_tokens)):
for j in range(len(src_tokens[i])):
x[i][j] = vocab.index(src_tokens[i][j])
if append_eos:
x[i][j + 1] = vocab.eos()
x = x.transpose(1, 0)
return x, torch.LongTensor(src_len)
def assert_eos_at_end(self, x, x_len, eos):
"""Asserts last token of every sentence in x is EOS"""
for i in range(len(x_len)):
self.assertEqual(
x[x_len[i] - 1][i],
eos,
(
"Expected eos (token id {eos}) at the end of sentence {i} "
"but got {other} instead"
).format(i=i, eos=eos, other=x[i][-1]),
)
def assert_word_dropout_correct(self, x, x_noised, x_len, l_noised):
# Expect only the first word (2 bpe tokens) of the first example
# was dropped out
self.assertEqual(x_len[0] - 2, l_noised[0])
for i in range(l_noised[0]):
self.assertEqual(x_noised[i][0], x[i + 2][0])
def test_word_dropout_with_eos(self):
vocab, x, x_len = self._get_test_data_with_bpe_cont_marker(append_eos=True)
with data_utils.numpy_seed(1234):
noising_gen = noising.WordDropout(vocab)
x_noised, l_noised = noising_gen.noising(x, x_len, 0.2)
self.assert_word_dropout_correct(
x=x, x_noised=x_noised, x_len=x_len, l_noised=l_noised
)
self.assert_eos_at_end(x=x_noised, x_len=l_noised, eos=vocab.eos())
def assert_word_blanking_correct(self, x, x_noised, x_len, l_noised, unk):
# Expect only the first word (2 bpe tokens) of the first example
# was blanked out
self.assertEqual(x_len[0], l_noised[0])
for i in range(l_noised[0]):
if i < 2:
self.assertEqual(x_noised[i][0], unk)
else:
self.assertEqual(x_noised[i][0], x[i][0])
def test_word_blank_with_eos(self):
vocab, x, x_len = self._get_test_data_with_bpe_cont_marker(append_eos=True)
with data_utils.numpy_seed(1234):
noising_gen = noising.WordDropout(vocab)
x_noised, l_noised = noising_gen.noising(x, x_len, 0.2, vocab.unk())
self.assert_word_blanking_correct(
x=x, x_noised=x_noised, x_len=x_len, l_noised=l_noised, unk=vocab.unk()
)
self.assert_eos_at_end(x=x_noised, x_len=l_noised, eos=vocab.eos())
def generate_unchanged_shuffle_map(self, length):
return {i: i for i in range(length)}
def assert_word_shuffle_matches_expected(
self,
x,
x_len,
max_shuffle_distance: int,
vocab: Dictionary,
expected_shufle_maps: List[Dict[int, int]],
expect_eos_at_end: bool,
bpe_end_marker=None,
):
"""
This verifies that with a given x, x_len, max_shuffle_distance, and
vocab, we get the expected shuffle result.
Args:
x: Tensor of shape (T x B) = (sequence_length, batch_size)
x_len: Tensor of length B = batch_size
max_shuffle_distance: arg to pass to noising
expected_shuffle_maps: List[mapping] where mapping is a
Dict[old_index, new_index], mapping x's elements from their
old positions in x to their new positions in x.
expect_eos_at_end: if True, check the output to make sure there is
an EOS at the end.
bpe_end_marker: str denoting the BPE end token. If this is not None, we
set the BPE cont token to None in the noising classes.
"""
bpe_cont_marker = None
if bpe_end_marker is None:
bpe_cont_marker = "@@"
with data_utils.numpy_seed(1234):
word_shuffle = noising.WordShuffle(
vocab, bpe_cont_marker=bpe_cont_marker, bpe_end_marker=bpe_end_marker
)
x_noised, l_noised = word_shuffle.noising(
x, x_len, max_shuffle_distance=max_shuffle_distance
)
# For every example, we have a different expected shuffle map. We check
# that each example is shuffled as expected according to each
# corresponding shuffle map.
for i in range(len(expected_shufle_maps)):
shuffle_map = expected_shufle_maps[i]
for k, v in shuffle_map.items():
self.assertEqual(x[k][i], x_noised[v][i])
# Shuffling should not affect the length of each example
for pre_shuffle_length, post_shuffle_length in zip(x_len, l_noised):
self.assertEqual(pre_shuffle_length, post_shuffle_length)
if expect_eos_at_end:
self.assert_eos_at_end(x=x_noised, x_len=l_noised, eos=vocab.eos())
def test_word_shuffle_with_eos(self):
vocab, x, x_len = self._get_test_data_with_bpe_cont_marker(append_eos=True)
# Assert word shuffle with max shuffle distance 0 causes input to be
# unchanged
self.assert_word_shuffle_matches_expected(
x=x,
x_len=x_len,
max_shuffle_distance=0,
vocab=vocab,
expected_shufle_maps=[
self.generate_unchanged_shuffle_map(example_len)
for example_len in x_len
],
expect_eos_at_end=True,
)
# Assert word shuffle with max shuffle distance 3 matches our expected
# shuffle order
self.assert_word_shuffle_matches_expected(
x=x,
x_len=x_len,
vocab=vocab,
max_shuffle_distance=3,
expected_shufle_maps=[
self.generate_unchanged_shuffle_map(x_len[0]),
{0: 0, 1: 3, 2: 1, 3: 2},
],
expect_eos_at_end=True,
)
def test_word_shuffle_with_eos_nonbpe(self):
"""The purpose of this is to test shuffling logic with word vocabs"""
vocab, x, x_len = self._get_test_data_with_word_vocab(append_eos=True)
# Assert word shuffle with max shuffle distance 0 causes input to be
# unchanged
self.assert_word_shuffle_matches_expected(
x=x,
x_len=x_len,
max_shuffle_distance=0,
vocab=vocab,
expected_shufle_maps=[
self.generate_unchanged_shuffle_map(example_len)
for example_len in x_len
],
expect_eos_at_end=True,
)
# Assert word shuffle with max shuffle distance 3 matches our expected
# shuffle order
self.assert_word_shuffle_matches_expected(
x=x,
x_len=x_len,
vocab=vocab,
max_shuffle_distance=3,
expected_shufle_maps=[
{0: 0, 1: 1, 2: 3, 3: 2},
{0: 0, 1: 2, 2: 1, 3: 3, 4: 4},
],
expect_eos_at_end=True,
)
def test_word_shuffle_without_eos(self):
"""Same result as word shuffle with eos except no EOS at end"""
vocab, x, x_len = self._get_test_data_with_bpe_cont_marker(append_eos=False)
# Assert word shuffle with max shuffle distance 0 causes input to be
# unchanged
self.assert_word_shuffle_matches_expected(
x=x,
x_len=x_len,
max_shuffle_distance=0,
vocab=vocab,
expected_shufle_maps=[
self.generate_unchanged_shuffle_map(example_len)
for example_len in x_len
],
expect_eos_at_end=False,
)
# Assert word shuffle with max shuffle distance 3 matches our expected
# shuffle order
self.assert_word_shuffle_matches_expected(
x=x,
x_len=x_len,
vocab=vocab,
max_shuffle_distance=3,
expected_shufle_maps=[
self.generate_unchanged_shuffle_map(x_len[0]),
{0: 0, 1: 3, 2: 1, 3: 2},
],
expect_eos_at_end=False,
)
def test_word_shuffle_without_eos_with_bpe_end_marker(self):
"""Same result as word shuffle without eos except using BPE end token"""
vocab, x, x_len = self._get_test_data_with_bpe_end_marker(append_eos=False)
# Assert word shuffle with max shuffle distance 0 causes input to be
# unchanged
self.assert_word_shuffle_matches_expected(
x=x,
x_len=x_len,
max_shuffle_distance=0,
vocab=vocab,
expected_shufle_maps=[
self.generate_unchanged_shuffle_map(example_len)
for example_len in x_len
],
expect_eos_at_end=False,
bpe_end_marker="_EOW",
)
# Assert word shuffle with max shuffle distance 3 matches our expected
# shuffle order
self.assert_word_shuffle_matches_expected(
x=x,
x_len=x_len,
vocab=vocab,
max_shuffle_distance=3,
expected_shufle_maps=[
self.generate_unchanged_shuffle_map(x_len[0]),
{0: 0, 1: 3, 2: 1, 3: 2},
],
expect_eos_at_end=False,
bpe_end_marker="_EOW",
)
def assert_no_eos_at_end(self, x, x_len, eos):
"""Asserts that the last token of each sentence in x is not EOS"""
for i in range(len(x_len)):
self.assertNotEqual(
x[x_len[i] - 1][i],
eos,
"Expected no eos (token id {eos}) at the end of sentence {i}.".format(
eos=eos, i=i
),
)
def test_word_dropout_without_eos(self):
"""Same result as word dropout with eos except no EOS at end"""
vocab, x, x_len = self._get_test_data_with_bpe_cont_marker(append_eos=False)
with data_utils.numpy_seed(1234):
noising_gen = noising.WordDropout(vocab)
x_noised, l_noised = noising_gen.noising(x, x_len, 0.2)
self.assert_word_dropout_correct(
x=x, x_noised=x_noised, x_len=x_len, l_noised=l_noised
)
self.assert_no_eos_at_end(x=x_noised, x_len=l_noised, eos=vocab.eos())
def test_word_blank_without_eos(self):
"""Same result as word blank with eos except no EOS at end"""
vocab, x, x_len = self._get_test_data_with_bpe_cont_marker(append_eos=False)
with data_utils.numpy_seed(1234):
noising_gen = noising.WordDropout(vocab)
x_noised, l_noised = noising_gen.noising(x, x_len, 0.2, vocab.unk())
self.assert_word_blanking_correct(
x=x, x_noised=x_noised, x_len=x_len, l_noised=l_noised, unk=vocab.unk()
)
self.assert_no_eos_at_end(x=x_noised, x_len=l_noised, eos=vocab.eos())
def _get_noising_dataset_batch(
self,
src_tokens_no_pad,
src_dict,
append_eos_to_tgt=False,
):
"""
Constructs a NoisingDataset and the corresponding
``LanguagePairDataset(NoisingDataset(src), src)``. If
*append_eos_to_tgt* is True, wrap the source dataset in
:class:`TransformEosDataset` to append EOS to the clean source when
using it as the target.
"""
src_dataset = test_utils.TestDataset(data=src_tokens_no_pad)
noising_dataset = noising.NoisingDataset(
src_dataset=src_dataset,
src_dict=src_dict,
seed=1234,
max_word_shuffle_distance=3,
word_dropout_prob=0.2,
word_blanking_prob=0.2,
noising_class=noising.UnsupervisedMTNoising,
)
tgt = src_dataset
language_pair_dataset = LanguagePairDataset(
src=noising_dataset, tgt=tgt, src_sizes=None, src_dict=src_dict
)
language_pair_dataset = TransformEosDataset(
language_pair_dataset,
src_dict.eos(),
append_eos_to_tgt=append_eos_to_tgt,
)
dataloader = torch.utils.data.DataLoader(
dataset=language_pair_dataset,
batch_size=2,
collate_fn=language_pair_dataset.collater,
)
denoising_batch_result = next(iter(dataloader))
return denoising_batch_result
def test_noising_dataset_with_eos(self):
src_dict, src_tokens, _ = self._get_test_data_with_bpe_cont_marker(
append_eos=True
)
# Format data for src_dataset
src_tokens = torch.t(src_tokens)
src_tokens_no_pad = []
for src_sentence in src_tokens:
src_tokens_no_pad.append(
utils.strip_pad(tensor=src_sentence, pad=src_dict.pad())
)
denoising_batch_result = self._get_noising_dataset_batch(
src_tokens_no_pad=src_tokens_no_pad, src_dict=src_dict
)
eos, pad = src_dict.eos(), src_dict.pad()
# Generated noisy source as source
expected_src = torch.LongTensor(
[[4, 5, 10, 11, 8, 12, 13, eos], [pad, pad, pad, 6, 8, 9, 7, eos]]
)
# Original clean source as target (right-padded)
expected_tgt = torch.LongTensor(
[[4, 5, 10, 11, 8, 12, 13, eos], [6, 7, 8, 9, eos, pad, pad, pad]]
)
generated_src = denoising_batch_result["net_input"]["src_tokens"]
tgt_tokens = denoising_batch_result["target"]
self.assertTensorEqual(expected_src, generated_src)
self.assertTensorEqual(expected_tgt, tgt_tokens)
def test_noising_dataset_without_eos(self):
"""
Similar to test noising dataset with eos except that we have to set
*append_eos_to_tgt* to ``True``.
"""
src_dict, src_tokens, _ = self._get_test_data_with_bpe_cont_marker(
append_eos=False
)
# Format data for src_dataset
src_tokens = torch.t(src_tokens)
src_tokens_no_pad = []
for src_sentence in src_tokens:
src_tokens_no_pad.append(
utils.strip_pad(tensor=src_sentence, pad=src_dict.pad())
)
denoising_batch_result = self._get_noising_dataset_batch(
src_tokens_no_pad=src_tokens_no_pad,
src_dict=src_dict,
append_eos_to_tgt=True,
)
eos, pad = src_dict.eos(), src_dict.pad()
# Generated noisy source as source
expected_src = torch.LongTensor(
[[4, 5, 10, 11, 8, 12, 13], [pad, pad, pad, 6, 8, 9, 7]]
)
# Original clean source as target (right-padded)
expected_tgt = torch.LongTensor(
[[4, 5, 10, 11, 8, 12, 13, eos], [6, 7, 8, 9, eos, pad, pad, pad]]
)
generated_src = denoising_batch_result["net_input"]["src_tokens"]
tgt_tokens = denoising_batch_result["target"]
self.assertTensorEqual(expected_src, generated_src)
self.assertTensorEqual(expected_tgt, tgt_tokens)
def assertTensorEqual(self, t1, t2):
self.assertEqual(t1.size(), t2.size(), "size mismatch")
self.assertEqual(t1.ne(t2).long().sum(), 0)
if __name__ == "__main__":
unittest.main()
| EXA-1-master | exa/libraries/fairseq/tests/test_noising.py |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import argparse
import tempfile
import unittest
import torch
from fairseq.data.dictionary import Dictionary
from fairseq.models.lstm import LSTMModel
from fairseq.tasks.fairseq_task import LegacyFairseqTask
DEFAULT_TEST_VOCAB_SIZE = 100
class DummyTask(LegacyFairseqTask):
def __init__(self, args):
super().__init__(args)
self.dictionary = get_dummy_dictionary()
if getattr(self.args, "ctc", False):
self.dictionary.add_symbol("<ctc_blank>")
self.src_dict = self.dictionary
self.tgt_dict = self.dictionary
@property
def source_dictionary(self):
return self.src_dict
@property
def target_dictionary(self):
return self.dictionary
def get_dummy_dictionary(vocab_size=DEFAULT_TEST_VOCAB_SIZE):
dummy_dict = Dictionary()
# add dummy symbol to satisfy vocab size
for id, _ in enumerate(range(vocab_size)):
dummy_dict.add_symbol("{}".format(id), 1000)
return dummy_dict
def get_dummy_task_and_parser():
"""
to build a fariseq model, we need some dummy parse and task. This function
is used to create dummy task and parser to faciliate model/criterion test
Note: we use FbSpeechRecognitionTask as the dummy task. You may want
to use other task by providing another function
"""
parser = argparse.ArgumentParser(
description="test_dummy_s2s_task", argument_default=argparse.SUPPRESS
)
DummyTask.add_args(parser)
args = parser.parse_args([])
task = DummyTask.setup_task(args)
return task, parser
class TestJitLSTMModel(unittest.TestCase):
def _test_save_and_load(self, scripted_module):
with tempfile.NamedTemporaryFile() as f:
scripted_module.save(f.name)
torch.jit.load(f.name)
def assertTensorEqual(self, t1, t2):
t1 = t1[~torch.isnan(t1)] # can cause size mismatch errors if there are NaNs
t2 = t2[~torch.isnan(t2)]
self.assertEqual(t1.size(), t2.size(), "size mismatch")
self.assertEqual(t1.ne(t2).long().sum(), 0)
def test_jit_and_export_lstm(self):
task, parser = get_dummy_task_and_parser()
LSTMModel.add_args(parser)
args = parser.parse_args([])
args.criterion = ""
model = LSTMModel.build_model(args, task)
scripted_model = torch.jit.script(model)
self._test_save_and_load(scripted_model)
def test_assert_jit_vs_nonjit_(self):
task, parser = get_dummy_task_and_parser()
LSTMModel.add_args(parser)
args = parser.parse_args([])
args.criterion = ""
model = LSTMModel.build_model(args, task)
model.eval()
scripted_model = torch.jit.script(model)
scripted_model.eval()
idx = len(task.source_dictionary)
iter = 100
# Inject random input and check output
seq_len_tensor = torch.randint(1, 10, (iter,))
num_samples_tensor = torch.randint(1, 10, (iter,))
for i in range(iter):
seq_len = seq_len_tensor[i]
num_samples = num_samples_tensor[i]
src_token = (torch.randint(0, idx, (num_samples, seq_len)),)
src_lengths = torch.randint(1, seq_len + 1, (num_samples,))
src_lengths, _ = torch.sort(src_lengths, descending=True)
# Force the first sample to have seq_len
src_lengths[0] = seq_len
prev_output_token = (torch.randint(0, idx, (num_samples, 1)),)
result = model(src_token[0], src_lengths, prev_output_token[0], None)
scripted_result = scripted_model(
src_token[0], src_lengths, prev_output_token[0], None
)
self.assertTensorEqual(result[0], scripted_result[0])
self.assertTensorEqual(result[1], scripted_result[1])
if __name__ == "__main__":
unittest.main()
| EXA-1-master | exa/libraries/fairseq/tests/test_lstm_jitable.py |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import argparse
import copy
import unittest
import torch
from torch.cuda.amp import GradScaler, autocast
from fairseq.optim import build_optimizer
@unittest.skipIf(not torch.cuda.is_available(), "test requires a GPU")
class TestGradientScalingAMP(unittest.TestCase):
def setUp(self):
self.x = torch.tensor([2.0]).cuda().half()
weight = 3.0
bias = 5.0
self.error = 1.0
self.target = torch.tensor([self.x * weight + bias + self.error]).cuda()
self.loss_fn = torch.nn.L1Loss()
self.model = torch.nn.Linear(1, 1)
self.model.weight.data = torch.tensor([[weight]])
self.model.bias.data = torch.tensor([bias])
self.model.cuda()
self.params = list(self.model.parameters())
self.namespace_dls = argparse.Namespace(
optimizer="adam",
lr=[0.1],
adam_betas="(0.9, 0.999)",
adam_eps=1e-8,
weight_decay=0.0,
threshold_loss_scale=1,
min_loss_scale=1e-4,
)
self.scaler = GradScaler(
init_scale=1,
growth_interval=1,
)
def run_iter(self, model, params, optimizer):
optimizer.zero_grad()
with autocast():
y = model(self.x)
loss = self.loss_fn(y, self.target)
self.scaler.scale(loss).backward()
self.assertEqual(loss, torch.tensor(1.0, device="cuda:0", dtype=torch.float16))
self.scaler.unscale_(optimizer)
grad_norm = optimizer.clip_grad_norm(0)
self.assertAlmostEqual(grad_norm.item(), 2.2361, 4)
self.scaler.step(optimizer)
self.scaler.update()
self.assertEqual(
model.weight,
torch.tensor([[3.1]], device="cuda:0", requires_grad=True),
)
self.assertEqual(
model.bias,
torch.tensor([5.1], device="cuda:0", requires_grad=True),
)
self.assertEqual(self.scaler.get_scale(), 2.0)
def test_automatic_mixed_precision(self):
model = copy.deepcopy(self.model)
params = list(model.parameters())
optimizer = build_optimizer(self.namespace_dls, params)
self.run_iter(model, params, optimizer)
| EXA-1-master | exa/libraries/fairseq/tests/test_amp_optimizer.py |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import torch
from fairseq.modules.sparse_multihead_attention import SparseMultiheadAttention
class TestSparseMultiheadAttention(unittest.TestCase):
def test_sparse_multihead_attention(self):
attn_weights = torch.randn(1, 8, 8)
bidirectional_sparse_mask = torch.tensor(
[
[0, 0, 0, 0, 0, float("-inf"), float("-inf"), 0],
[0, 0, 0, 0, 0, float("-inf"), float("-inf"), 0],
[0, 0, 0, 0, 0, float("-inf"), float("-inf"), 0],
[0, 0, 0, 0, 0, float("-inf"), float("-inf"), 0],
[float("-inf"), float("-inf"), float("-inf"), 0, 0, 0, 0, 0],
[float("-inf"), float("-inf"), float("-inf"), 0, 0, 0, 0, 0],
[float("-inf"), float("-inf"), float("-inf"), 0, 0, 0, 0, 0],
[float("-inf"), float("-inf"), float("-inf"), 0, 0, 0, 0, 0],
]
)
bidirectional_attention = SparseMultiheadAttention(
16, 1, stride=4, expressivity=1, is_bidirectional=True
)
bidirectional_attention_sparse_mask = (
bidirectional_attention.buffered_sparse_mask(attn_weights, 8, 8)
)
torch.all(
torch.eq(bidirectional_attention_sparse_mask, bidirectional_sparse_mask)
)
sparse_mask = torch.tensor(
[
[
0,
float("-inf"),
float("-inf"),
float("-inf"),
float("-inf"),
float("-inf"),
float("-inf"),
float("-inf"),
],
[
0,
0,
float("-inf"),
float("-inf"),
float("-inf"),
float("-inf"),
float("-inf"),
float("-inf"),
],
[
0,
0,
0,
float("-inf"),
float("-inf"),
float("-inf"),
float("-inf"),
float("-inf"),
],
[
0,
0,
0,
0,
float("-inf"),
float("-inf"),
float("-inf"),
float("-inf"),
],
[0, 0, 0, 0, 0, float("-inf"), float("-inf"), float("-inf")],
[
float("-inf"),
float("-inf"),
float("-inf"),
0,
0,
0,
float("-inf"),
float("-inf"),
],
[
float("-inf"),
float("-inf"),
float("-inf"),
0,
0,
0,
0,
float("-inf"),
],
[float("-inf"), float("-inf"), float("-inf"), 0, 0, 0, 0, 0],
]
)
attention = SparseMultiheadAttention(
16, 1, stride=4, expressivity=1, is_bidirectional=False
)
attention_sparse_mask = attention.buffered_sparse_mask(attn_weights, 8, 8)
torch.all(torch.eq(attention_sparse_mask, sparse_mask))
if __name__ == "__main__":
unittest.main()
| EXA-1-master | exa/libraries/fairseq/tests/test_sparse_multihead_attention.py |
# Copyright (c) Facebook, Inc. and its affiliates.
#
# This source code is licensed under the MIT license found in the
# LICENSE file in the root directory of this source tree.
import unittest
import uuid
from fairseq.logging import metrics
class TestMetrics(unittest.TestCase):
def test_nesting(self):
with metrics.aggregate() as a:
metrics.log_scalar("loss", 1)
with metrics.aggregate() as b:
metrics.log_scalar("loss", 2)
self.assertEqual(a.get_smoothed_values()["loss"], 1.5)
self.assertEqual(b.get_smoothed_values()["loss"], 2)
def test_new_root(self):
with metrics.aggregate() as a:
metrics.log_scalar("loss", 1)
with metrics.aggregate(new_root=True) as b:
metrics.log_scalar("loss", 2)
self.assertEqual(a.get_smoothed_values()["loss"], 1)
self.assertEqual(b.get_smoothed_values()["loss"], 2)
def test_nested_new_root(self):
with metrics.aggregate() as layer1:
metrics.log_scalar("loss", 1)
with metrics.aggregate(new_root=True) as layer2:
metrics.log_scalar("loss", 2)
with metrics.aggregate() as layer3:
metrics.log_scalar("loss", 3)
with metrics.aggregate(new_root=True) as layer4:
metrics.log_scalar("loss", 4)
metrics.log_scalar("loss", 1.5)
self.assertEqual(layer4.get_smoothed_values()["loss"], 4)
self.assertEqual(layer3.get_smoothed_values()["loss"], 3)
self.assertEqual(layer2.get_smoothed_values()["loss"], 2.5)
self.assertEqual(layer1.get_smoothed_values()["loss"], 1.25)
def test_named(self):
name = str(uuid.uuid4())
metrics.reset_meters(name)
with metrics.aggregate(name):
metrics.log_scalar("loss", 1)
metrics.log_scalar("loss", 3)
with metrics.aggregate(name):
metrics.log_scalar("loss", 2)
self.assertEqual(metrics.get_smoothed_values(name)["loss"], 1.5)
def test_nested_duplicate_names(self):
name = str(uuid.uuid4())
metrics.reset_meters(name)
with metrics.aggregate(name):
metrics.log_scalar("loss", 1)
with metrics.aggregate() as other:
with metrics.aggregate(name):
metrics.log_scalar("loss", 2)
metrics.log_scalar("loss", 6)
self.assertEqual(metrics.get_smoothed_values(name)["loss"], 3)
self.assertEqual(other.get_smoothed_values()["loss"], 2)
if __name__ == "__main__":
unittest.main()
| EXA-1-master | exa/libraries/fairseq/tests/test_metrics.py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.