python_code stringlengths 0 1.02M | repo_name stringlengths 9 48 | file_path stringlengths 5 114 |
|---|---|---|
import hashlib
import os
import urllib
import warnings
from typing import Any, Union, List
from pkg_resources import packaging
import torch
from PIL import Image
from torchvision.transforms import Compose, Resize, CenterCrop, ToTensor, Normalize
from tqdm import tqdm
from .model import build_model
from .simple_tokeni... | CLIP-main | clip/clip.py |
import gzip
import html
import os
from functools import lru_cache
import ftfy
import regex as re
@lru_cache()
def default_bpe():
return os.path.join(os.path.dirname(os.path.abspath(__file__)), "bpe_simple_vocab_16e6.txt.gz")
@lru_cache()
def bytes_to_unicode():
"""
Returns list of utf-8 byte and a corr... | CLIP-main | clip/simple_tokenizer.py |
import numpy as np
import pytest
import torch
from PIL import Image
import clip
@pytest.mark.parametrize('model_name', clip.available_models())
def test_consistency(model_name):
device = "cpu"
jit_model, transform = clip.load(model_name, device=device, jit=True)
py_model, _ = clip.load(model_name, device... | CLIP-main | tests/test_consistency.py |
from setuptools import setup, find_packages
setup(
name = 'memformer',
packages = find_packages(exclude=['examples']),
version = '0.3.1',
license='MIT',
description = 'Memformer - Pytorch',
author = 'Phil Wang',
author_email = 'lucidrains@gmail.com',
url = 'https://github.com/lucidrains/memformer',
k... | memformer-main | setup.py |
from functools import partial
import torch
from torch import nn
import torch.nn.functional as F
from torch.nn.utils.rnn import pad_sequence
def top_p(logits, thres = 0.9):
sorted_logits, sorted_indices = torch.sort(logits, descending=True)
cum_probs = torch.cumsum(F.softmax(sorted_logits, dim=-1), dim=-1)
... | memformer-main | memformer/autoregressive_wrapper.py |
from memformer.memformer import Memformer
from memformer.mrbp import memory_replay_backprop
| memformer-main | memformer/__init__.py |
import torch
from operator import itemgetter
def memory_replay_backprop(
model,
src,
tgt,
src_mask = None,
tgt_mask = None
):
b, *_ = src.shape
# get initial memory and max sequence length from encoder
mem_init = model.get_initial_mem(b)
max_seq_len = model.encoder.max_seq_len
... | memformer-main | memformer/mrbp.py |
import math
import torch
from torch import nn, einsum
from functools import partial
import torch.nn.functional as F
from inspect import isfunction
from einops import rearrange, repeat
from collections import namedtuple
from memformer.autoregressive_wrapper import AutoregressiveWrapper
# constants
Results = namedtuple... | memformer-main | memformer/memformer.py |
from setuptools import setup, find_packages
setup(
name = 'enformer-pytorch',
packages = find_packages(exclude=[]),
include_package_data = True,
version = '0.7.6',
license='MIT',
description = 'Enformer - Pytorch',
author = 'Phil Wang',
author_email = 'lucidrains@gmail.com',
long_description_content_... | enformer-pytorch-main | setup.py |
import torch
from enformer_pytorch import Enformer
enformer = Enformer.from_pretrained('EleutherAI/enformer-official-rough').cuda()
enformer.eval()
data = torch.load('./data/test-sample.pt')
seq, target = data['sequence'].cuda(), data['target'].cuda()
with torch.no_grad():
corr_coef = enformer(
seq,
... | enformer-pytorch-main | test_pretrained.py |
from torchmetrics import Metric
from typing import Optional
import torch
class MeanPearsonCorrCoefPerChannel(Metric):
is_differentiable: Optional[bool] = False
full_state_update:bool = False
higher_is_better: Optional[bool] = True
def __init__(self, n_channels:int, dist_sync_on_step=False):
""... | enformer-pytorch-main | enformer_pytorch/metrics.py |
from enformer_pytorch.config_enformer import EnformerConfig
from enformer_pytorch.modeling_enformer import Enformer, SEQUENCE_LENGTH, AttentionPool
from enformer_pytorch.data import seq_indices_to_one_hot, str_to_one_hot, GenomeIntervalDataset, FastaInterval | enformer-pytorch-main | enformer_pytorch/__init__.py |
import math
import torch
from torch import nn, einsum
import torch.nn.functional as F
from torch.utils.checkpoint import checkpoint_sequential
from einops import rearrange, reduce
from einops.layers.torch import Rearrange
from enformer_pytorch.data import str_to_one_hot, seq_indices_to_one_hot
from enformer_pytorch.... | enformer-pytorch-main | enformer_pytorch/modeling_enformer.py |
from transformers import PretrainedConfig
class EnformerConfig(PretrainedConfig):
model_type = "enformer"
def __init__(
self,
dim = 1536,
depth = 11,
heads = 8,
output_heads = dict(human = 5313, mouse= 1643),
target_length = 896,
attn_dim_key = 64,
... | enformer-pytorch-main | enformer_pytorch/config_enformer.py |
import torch
from typing import Optional
from copy import deepcopy
from contextlib import contextmanager
import torch.nn.functional as F
from torch import nn, einsum
from einops import rearrange, repeat
from einops.layers.torch import Rearrange
from enformer_pytorch.modeling_enformer import Enformer, poisson_loss
fr... | enformer-pytorch-main | enformer_pytorch/finetune.py |
import torch
import torch.nn.functional as F
from torch.utils.data import Dataset
import polars as pl
import numpy as np
from random import randrange, random
from pathlib import Path
from pyfaidx import Fasta
# helper functions
def exists(val):
return val is not None
def identity(t):
return t
def cast_list... | enformer-pytorch-main | enformer_pytorch/data.py |
from einops import rearrange
def copy_bn(mod, vars, path):
bn_offset = vars[f'{path}offset:0']
bn_scale = vars[f'{path}scale:0']
ema_path = '/'.join(path.split('/')[:-1]) + '/'
bn_running_mean = vars[f'{ema_path}moving_mean/average:0']
bn_running_var = vars[f'{ema_path}moving_variance/average:0']
... | enformer-pytorch-main | scripts/tf_to_torch.py |
import sys
from setuptools import setup, find_packages
sys.path[0:0] = ['big_sleep']
from version import __version__
setup(
name = 'big-sleep',
packages = find_packages(),
include_package_data = True,
entry_points={
'console_scripts': [
'dream = big_sleep.cli:main',
],
},
version = __version... | big-sleep-main | setup.py |
import time
import shutil
import torch
from big_sleep import Imagine
terminate = False
def signal_handling(signum,frame):
global terminate
terminate = True
num_attempts = 4
for attempt in range(num_attempts):
dream = Imagine(
text = "an armchair in the form of pikachu\\an armchair imitating pikac... | big-sleep-main | test/multi_prompt_minmax.py |
__version__ = '0.9.1'
| big-sleep-main | big_sleep/version.py |
"""Good differentiable image resampling for PyTorch."""
from functools import update_wrapper
import math
import torch
from torch.nn import functional as F
def sinc(x):
return torch.where(x != 0, torch.sin(math.pi * x) / (math.pi * x), x.new_ones([]))
def lanczos(x, a):
cond = torch.logical_and(-a < x, x ... | big-sleep-main | big_sleep/resample.py |
# Exponential Moving Average (from https://gist.github.com/crowsonkb/76b94d5238272722290734bf4725d204)
"""Exponential moving average for PyTorch. Adapted from
https://www.zijianhu.com/post/pytorch/ema/ by crowsonkb
"""
from copy import deepcopy
import torch
from torch import nn
class EMA(nn.Module):
def __init__... | big-sleep-main | big_sleep/ema.py |
from big_sleep.big_sleep import BigSleep, Imagine
| big-sleep-main | big_sleep/__init__.py |
# this code is a copy from huggingface
# with some minor modifications
import torch
import torch.nn as nn
import torch.nn.functional as F
import math
import json
import copy
import logging
import os
import shutil
import tempfile
from functools import wraps
from hashlib import sha256
import sys
from io import open
imp... | big-sleep-main | big_sleep/biggan.py |
import fire
import random as rnd
from big_sleep import Imagine, version
from pathlib import Path
from .version import __version__;
def train(
text=None,
img=None,
text_min="",
lr = .07,
image_size = 512,
gradient_accumulate_every = 1,
epochs = 20,
iterations = 1050,
save_every = 50... | big-sleep-main | big_sleep/cli.py |
import os
import sys
import subprocess
import signal
import string
import re
from datetime import datetime
from pathlib import Path
import random
import torch
import torch.nn.functional as F
from torch import nn
from torch.optim import Adam
from torchvision.utils import save_image
import torchvision.transforms as T
f... | big-sleep-main | big_sleep/big_sleep.py |
from collections import OrderedDict
from typing import Tuple, Union
import torch
import torch.nn.functional as F
from torch import nn
from pathlib import Path
import hashlib
import os
import urllib
import warnings
from typing import Union, List
import torch
from PIL import Image
from torchvision.transforms import Co... | big-sleep-main | big_sleep/clip.py |
from setuptools import setup, find_packages
setup(
name = 'rotary-embedding-torch',
packages = find_packages(),
version = '0.3.0',
license='MIT',
description = 'Rotary Embedding - Pytorch',
long_description_content_type = 'text/markdown',
author = 'Phil Wang',
author_email = 'lucidrains@gmail.com',
u... | rotary-embedding-torch-main | setup.py |
from rotary_embedding_torch.rotary_embedding_torch import apply_rotary_emb, RotaryEmbedding, broadcat, apply_learned_rotations
| rotary-embedding-torch-main | rotary_embedding_torch/__init__.py |
from math import pi, log
import torch
from torch import nn, einsum
from einops import rearrange, repeat
# helper functions
def exists(val):
return val is not None
def broadcat(tensors, dim = -1):
num_tensors = len(tensors)
shape_lens = set(list(map(lambda t: len(t.shape), tensors)))
assert len(shap... | rotary-embedding-torch-main | rotary_embedding_torch/rotary_embedding_torch.py |
from setuptools import setup, find_packages
setup(
name = 'lambda-networks',
packages = find_packages(),
version = '0.4.0',
license='MIT',
description = 'Lambda Networks - Pytorch',
author = 'Phil Wang',
author_email = 'lucidrains@gmail.com',
url = 'https://github.com/lucidrains/lambda-networks',
key... | lambda-networks-main | setup.py |
from lambda_networks.lambda_networks import LambdaLayer
λLayer = LambdaLayer | lambda-networks-main | lambda_networks/__init__.py |
import torch
from torch import nn, einsum
from einops import rearrange
# helpers functions
def exists(val):
return val is not None
def default(val, d):
return val if exists(val) else d
def calc_rel_pos(n):
pos = torch.meshgrid(torch.arange(n), torch.arange(n))
pos = rearrange(torch.stack(pos), 'n i ... | lambda-networks-main | lambda_networks/lambda_networks.py |
import tensorflow as tf
from einops.layers.tensorflow import Rearrange
from tensorflow.keras.layers import Conv2D, BatchNormalization, Conv3D, ZeroPadding3D, Softmax, Lambda, Add, Layer
from tensorflow.keras import initializers
from tensorflow import einsum, nn, meshgrid
# helpers functions
def exists(val):
retur... | lambda-networks-main | lambda_networks/tfkeras.py |
from setuptools import setup, find_packages
setup(
name = 'speculative-decoding',
packages = find_packages(exclude=[]),
version = '0.0.1',
license='MIT',
description = 'Speculative Decoding',
author = 'Phil Wang',
author_email = 'lucidrains@gmail.com',
long_description_content_type = 'text/markdown',
... | speculative-decoding-main | setup.py |
import gzip
import random
import tqdm
import numpy as np
import time
from functools import wraps
import torch
from torch.optim import Adam
from torch.nn import functional as F
from torch.utils.data import DataLoader, Dataset
from speculative_decoding import (
Decoder,
base_decoding,
speculative_decoding
)... | speculative-decoding-main | train.py |
from speculative_decoding.speculative_decoding import (
Decoder,
base_decoding,
speculative_decoding
)
| speculative-decoding-main | speculative_decoding/__init__.py |
import math
import torch
from torch.nn import Module, ModuleList
from torch import nn, einsum, Tensor
import torch.nn.functional as F
from rotary_embedding_torch import RotaryEmbedding
from beartype import beartype
from einops import rearrange
# helper functions
def exists(val):
return val is not None
def def... | speculative-decoding-main | speculative_decoding/speculative_decoding.py |
from setuptools import setup, find_packages
setup(
name = 'TPDNE-utils',
packages = find_packages(exclude=[]),
version = '0.0.11',
license='MIT',
description = 'TPDNE',
include_package_data = True,
author = 'Phil Wang',
author_email = 'lucidrains@gmail.com',
long_description_content_type = 'text/mark... | TPDNE-main | setup.py |
import os
import sys
import numpy as np
from time import time, sleep
from pathlib import Path
from functools import wraps
from PIL import Image
from beartype import beartype
from beartype.typing import Callable, Optional
from einops import rearrange, repeat
# templating
from jinja2 import Environment, FileSystemLoa... | TPDNE-main | TPDNE_utils/tpdne.py |
from TPDNE_utils.tpdne import sample_image_and_save_repeatedly
| TPDNE-main | TPDNE_utils/__init__.py |
from setuptools import setup, find_packages
setup(
name = 'unet_stylegan2',
packages = find_packages(),
scripts=['bin/unet_stylegan2'],
version = '0.5.1',
license='GPLv3+',
description = 'StyleGan2 with UNet Discriminator, in Pytorch',
author = 'Phil Wang',
author_email = 'lucidrains@gmail.com',
url ... | unet-stylegan2-master | setup.py |
import torch
import torch.nn.functional as F
def DiffAugment(x, types=[]):
for p in types:
for f in AUGMENT_FNS[p]:
x = f(x)
return x.contiguous(memory_format = torch.contiguous_format)
def rand_brightness(x):
x = x + (torch.rand(x.size(0), 1, 1, 1, dtype=x.dtype, device=x.device) - 0.... | unet-stylegan2-master | unet_stylegan2/diff_augment.py |
from unet_stylegan2.unet_stylegan2 import Trainer, StyleGAN2, NanException | unet-stylegan2-master | unet_stylegan2/__init__.py |
import os
import sys
import math
import fire
import json
from tqdm import tqdm
from math import floor, log2
from random import random
from shutil import rmtree
from functools import partial
import multiprocessing
import numpy as np
import torch
from torch import nn
from torch.utils import data
import torch.nn.function... | unet-stylegan2-master | unet_stylegan2/unet_stylegan2.py |
from setuptools import setup, find_packages
setup(
name = 'transformer-in-transformer',
packages = find_packages(),
version = '0.1.2',
license='MIT',
description = 'Transformer in Transformer - Pytorch',
author = 'Phil Wang',
author_email = 'lucidrains@gmail.com',
url = 'https://github.com/lucidrains/t... | transformer-in-transformer-main | setup.py |
from transformer_in_transformer.tnt import TNT
| transformer-in-transformer-main | transformer_in_transformer/__init__.py |
import torch
import torch.nn.functional as F
from torch import nn, einsum
from einops import rearrange, repeat
from einops.layers.torch import Rearrange
# helpers
def exists(val):
return val is not None
def default(val, d):
return val if exists(val) else d
def divisible_by(val, divisor):
return (val % ... | transformer-in-transformer-main | transformer_in_transformer/tnt.py |
from setuptools import setup, find_packages
setup(
name = 'learning-to-expire-pytorch',
packages = find_packages(exclude=['examples']),
version = '0.0.2',
license='MIT',
description = 'Learning to Expire - Pytorch',
author = 'Phil Wang',
author_email = 'lucidrains@gmail.com',
url = 'https://github.com/... | learning-to-expire-pytorch-main | setup.py |
from learning_to_expire_pytorch.learning_to_expire_pytorch import ExpireSpanTransformerXL
| learning-to-expire-pytorch-main | learning_to_expire_pytorch/__init__.py |
import torch
from torch import nn, einsum
import torch.nn.functional as F
from einops import rearrange, repeat
from collections import namedtuple
# constants
Memory = namedtuple('Memory', ['mems', 'elapsed_times'])
# helpers
def exists(val):
return val is not None
def default(val, d):
return val if exists(... | learning-to-expire-pytorch-main | learning_to_expire_pytorch/learning_to_expire_pytorch.py |
from setuptools import setup, find_packages
setup(
name = 'simple-hierarchical-transformer',
packages = find_packages(exclude=[]),
version = '0.1.2',
license='MIT',
description = 'Simple Hierarchical Transformer',
author = 'Phil Wang',
author_email = 'lucidrains@gmail.com',
long_description_content_typ... | simple-hierarchical-transformer-main | setup.py |
import gzip
import random
import tqdm
import numpy as np
import torch
from torch.optim import Adam
from torch.nn import functional as F
from torch.utils.data import DataLoader, Dataset
from simple_hierarchical_transformer import HierarchicalTransformer
from accelerate import Accelerator
# hf accelerator
accelerato... | simple-hierarchical-transformer-main | train.py |
import torch
from torch import nn, einsum
import torch.nn.functional as F
from collections import namedtuple
from functools import wraps
from packaging import version
from einops import rearrange
# constants
Config = namedtuple('EfficientAttentionConfig', ['enable_flash', 'enable_math', 'enable_mem_efficient'])
# ... | simple-hierarchical-transformer-main | simple_hierarchical_transformer/attention.py |
import math
from functools import partial
from itertools import zip_longest
import torch
import torch.nn.functional as F
from torch import nn, einsum
from einops import rearrange, repeat
from einops.layers.torch import Rearrange
from simple_hierarchical_transformer.attention import Attend
from typing import Tuple
f... | simple-hierarchical-transformer-main | simple_hierarchical_transformer/simple_hierarchical_transformer.py |
from simple_hierarchical_transformer.simple_hierarchical_transformer import HierarchicalTransformer
| simple-hierarchical-transformer-main | simple_hierarchical_transformer/__init__.py |
from setuptools import setup, find_packages
setup(
name = 'flamingo-pytorch',
packages = find_packages(exclude=[]),
version = '0.1.2',
license='MIT',
description = 'Flamingo - Pytorch',
author = 'Phil Wang',
author_email = 'lucidrains@gmail.com',
url = 'https://github.com/lucidrains/flamingo-pytorch',
... | flamingo-pytorch-main | setup.py |
import torch
from torch import nn, einsum
import torch.nn.functional as F
from einops import rearrange, repeat
from einops_exts import rearrange_many, repeat_many
def exists(val):
return val is not None
def FeedForward(dim, mult = 4):
inner_dim = int(dim * mult)
return nn.Sequential(
nn.LayerNorm... | flamingo-pytorch-main | flamingo_pytorch/flamingo_pytorch.py |
from flamingo_pytorch.flamingo_pytorch import PerceiverResampler, GatedCrossAttentionBlock
from flamingo_pytorch.flamingo_palm import FlamingoPaLM
| flamingo-pytorch-main | flamingo_pytorch/__init__.py |
import torch
import torch.nn.functional as F
from einops import rearrange, repeat
from torch import einsum, nn
from flamingo_pytorch.flamingo_pytorch import GatedCrossAttentionBlock, PerceiverResampler
# helper functions
def exists(val):
return val is not None
# for controlling freezing during training of flami... | flamingo-pytorch-main | flamingo_pytorch/flamingo_palm.py |
from setuptools import setup, find_packages
setup(
name = 'cross-transformers-pytorch',
packages = find_packages(),
version = '0.0.2',
license='MIT',
description = 'Cross Transformers - Pytorch',
author = 'Phil Wang',
author_email = 'lucidrains@gmail.com',
url = 'https://github.com/lucidrains/cross-tra... | cross-transformers-pytorch-main | setup.py |
from cross_transformers_pytorch.cross_transformers_pytorch import CrossTransformer
| cross-transformers-pytorch-main | cross_transformers_pytorch/__init__.py |
import torch
from torch import nn, einsum
import torch.nn.functional as F
from einops import rearrange
class CrossTransformer(nn.Module):
def __init__(
self,
dim = 512,
dim_key = 128,
dim_value = 128
):
super().__init__()
self.scale = dim_key ** -0.5
sel... | cross-transformers-pytorch-main | cross_transformers_pytorch/cross_transformers_pytorch.py |
from setuptools import setup, find_packages
setup(
name = 'spear-tts-pytorch',
packages = find_packages(exclude=[]),
version = '0.2.1',
license='MIT',
description = 'Spear-TTS - Pytorch',
author = 'Phil Wang',
author_email = 'lucidrains@gmail.com',
long_description_content_type = 'text/markdown',
url... | spear-tts-pytorch-main | setup.py |
from spear_tts_pytorch.spear_tts_pytorch import (
TextToSemantic,
SpeechSpeechPretrainWrapper,
SemanticToTextWrapper,
TextToSemanticWrapper,
SemanticToTextDatasetGenerator
)
from spear_tts_pytorch.trainer import (
SpeechSpeechPretrainer,
SemanticToTextTrainer,
TextToSemanticTrainer
)
f... | spear-tts-pytorch-main | spear_tts_pytorch/__init__.py |
import torch
from torch import nn, einsum
import torch.nn.functional as F
from collections import namedtuple
from functools import wraps
from packaging import version
from einops import rearrange
# constants
Config = namedtuple('EfficientAttentionConfig', ['enable_flash', 'enable_math', 'enable_mem_efficient'])
# ... | spear-tts-pytorch-main | spear_tts_pytorch/attend.py |
import math
from pathlib import Path
from functools import partial
import torch
import torch.nn.functional as F
from torch.nn.utils.rnn import pad_sequence
from torch import Tensor, nn, einsum, FloatTensor, IntTensor, LongTensor
from torch.nn import Module, ModuleList
from torch.utils.data import Dataset
from einops... | spear-tts-pytorch-main | spear_tts_pytorch/spear_tts_pytorch.py |
import re
from pathlib import Path
from shutil import rmtree
from beartype import beartype
from beartype.door import is_bearable
from beartype.typing import Union, Optional, Tuple
import torch
from torch import nn, LongTensor, IntTensor
from torch.utils.data import ConcatDataset
from torch.optim.lr_scheduler import C... | spear-tts-pytorch-main | spear_tts_pytorch/trainer.py |
from pathlib import Path
import torch
from torch.utils.data import Dataset
from beartype import beartype
# mock dataset
class MockDataset(Dataset):
def __init__(self, length: int):
self.length = length
def __len__(self):
return self.length
def __getitem__(self, ind):
return tor... | spear-tts-pytorch-main | spear_tts_pytorch/data.py |
from setuptools import setup, find_packages
setup(
name = 'coordinate-descent-attention',
packages = find_packages(exclude=[]),
version = '0.0.11',
license='MIT',
description = 'Coordinate Descent Attention - Pytorch',
author = 'Phil Wang',
author_email = 'lucidrains@gmail.com',
long_description_conten... | coordinate-descent-attention-main | setup.py |
import gzip
import random
import tqdm
import numpy as np
import torch
from torch.optim import Adam
from torch.nn import functional as F
from torch.utils.data import DataLoader, Dataset
from coordinate_descent_attention import Transformer, AutoregressiveWrapper
# constants
NUM_BATCHES = int(1e5)
BATCH_SIZE = 4
GRADI... | coordinate-descent-attention-main | train.py |
import torch
from torch import nn
import torch.nn.functional as F
from einops import rearrange
# helper function
def exists(val):
return val is not None
def eval_decorator(fn):
def inner(model, *args, **kwargs):
was_training = model.training
model.eval()
out = fn(model, *args, **kwar... | coordinate-descent-attention-main | coordinate_descent_attention/autoregressive_wrapper.py |
from coordinate_descent_attention.coordinate_descent_attention import Transformer, Attention
from coordinate_descent_attention.autoregressive_wrapper import AutoregressiveWrapper
| coordinate-descent-attention-main | coordinate_descent_attention/__init__.py |
import torch
import torch.nn.functional as F
from torch import nn, einsum
from einops import rearrange, repeat
from colt5_attention import coor_descent
from colt5_attention.triton_coor_descent import triton_coor_descent
# helpers
def exists(val):
return val is not None
def default(val, d):
return val if ex... | coordinate-descent-attention-main | coordinate_descent_attention/coordinate_descent_attention.py |
# -*- coding: utf-8 -*-
"""HyenaDNA training & inference example (Public)
This code is adapted from the original colab tutorial on HyenaDNA. Check that out for an easier entry point into the code.
We provide the code here as an example for those who want something outside collab, with Huggingface integration.
Origin... | hyena-dna-main | standalone_hyenadna.py |
#@title Huggingface Pretrained Wrapper
"""
This is script is a simple HuggingFace wrapper around a HyenaDNA model, to enable a one click example
of how to load the pretrained weights and get embeddings.
It will instantiate a HyenaDNA model (model class is in the `standalone_hyenadna.py`), and handle the downloading... | hyena-dna-main | huggingface.py |
import copy
import os
import random
import time
from functools import partial, wraps
from typing import Callable, List, Sequence
import hydra
import numpy as np
import pytorch_lightning as pl
import torch
import torch.nn as nn
import wandb
from hydra.utils import get_original_cwd
from omegaconf import DictConfig, Omeg... | hyena-dna-main | train.py |
import torch
import torch.nn.functional as F
from einops import rearrange
from fftconv import fftconv_fwd, fftconv_bwd
def fftconv_ref(u, k, D, dropout_mask):
seqlen = u.shape[-1]
fft_size = 2 * seqlen
k_f = torch.fft.rfft(k, n=fft_size) / fft_size
u_f = torch.fft.rfft(u.to(dtype=k.dtype), n=fft_siz... | hyena-dna-main | csrc/fftconv/launch_fftconv.py |
# Adapted from https://github.com/NVIDIA/apex/blob/master/setup.py
import torch
from torch.utils.cpp_extension import BuildExtension, CppExtension, CUDAExtension, CUDA_HOME
from setuptools import setup, find_packages
import subprocess
import sys
import warnings
import os
# ninja build does not work unless include_dir... | hyena-dna-main | csrc/fftconv/setup.py |
import math
import re
import numpy as np
# N = 8192
N = 16384
# The case of 0 / N is special, we want to simplify it to 0 / 2 instead of 0 / 1
numerator = np.arange(1, N // 8 + 1)
gcd = np.gcd(numerator, N)
num = numerator // gcd
denom = N // gcd
lut_vals = ['T_2_0'] + [f'T_{d}_{n}' for n, d in zip(num, denom)]
lut_... | hyena-dna-main | csrc/fftconv/lut_code_gen.py |
#!/usr/bin/env python3
import argparse
import yaml
from tqdm import tqdm
import typing as tp
import numpy as np
import pandas as pd
from copy import deepcopy
from collections import OrderedDict
import torch
torch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.allow_tf32 = True
import torch.nn.functional ... | hyena-dna-main | evals/soft_prompting_genomics.py |
#!/usr/bin/env python3
import argparse
import yaml
from tqdm import tqdm
import typing as tp
import numpy as np
import pandas as pd
from copy import deepcopy
from collections import OrderedDict
import torch
torch.backends.cuda.matmul.allow_tf32 = True
torch.backends.cudnn.allow_tf32 = True
import torch.nn.functional ... | hyena-dna-main | evals/instruction_tuned_genomics.py |
import torch
import argparse
import os
import sys
import yaml
from tqdm import tqdm
import json
from src.models.sequence.long_conv_lm import DNAEmbeddingModel
from src.tasks.decoders import SequenceDecoder
from src.dataloaders import SequenceDataset
import numpy as np
from src.dataloaders.datasets.hg38_char_token... | hyena-dna-main | evals/hg38_inference_decoder.py |
import torch
import argparse
import os
import sys
import yaml
from tqdm import tqdm
import json
sys.path.append(os.environ.get("SAFARI_PATH", "."))
from src.models.sequence.long_conv_lm import ConvLMHeadModel
# from transformers import AutoTokenizer, GPT2LMHeadModel
# from spacy.lang.en.stop_words import STOP_WO... | hyena-dna-main | evals/hg38_inference.py |
import math
import torch
import torch.nn.functional as F
from sklearn.metrics import f1_score, roc_auc_score
from functools import partial
import torchmetrics.functional as tm_f
import torch.distributions as dist
from sklearn.metrics import f1_score, roc_auc_score, matthews_corrcoef
from torchmetrics import Metric
from... | hyena-dna-main | src/tasks/metrics.py |
# Inspired by https://github.com/NVIDIA/NeMo/blob/main/nemo/collections/common/metrics/perplexity.py
# But we compute the perplexity correctly: exp(average(nll)), not average(exp(nll))
# Also adapted from https://github.com/Lightning-AI/metrics/blob/master/src/torchmetrics/text/perplexity.py
# But we pass in the loss t... | hyena-dna-main | src/tasks/torchmetrics.py |
from typing import Optional, List, Tuple
import math
import functools
import collections
import torch
import torch.nn as nn
import torch.nn.functional as F
from einops import rearrange
from omegaconf import ListConfig
from src.models.nn.components import ReversibleInstanceNorm1dInput, ReversibleInstanceNorm1dOutput, \
... | hyena-dna-main | src/tasks/tasks.py |
import torch
import torch.nn as nn
import torch.nn.functional as F
from einops import rearrange, reduce
import src.models.nn.utils as U
import src.utils as utils
import src.utils.config
import src.utils.train
log = src.utils.train.get_logger(__name__)
class Decoder(nn.Module):
"""This class doesn't do much but ... | hyena-dna-main | src/tasks/decoders.py |
import datetime
import math
from typing import ForwardRef
import torch
from torch import nn
import torch.nn.functional as F
from einops import rearrange, repeat
import src.models.nn.utils as U
import src.utils as utils
import src.utils.config
from src.models.sequence.block import SequenceResidualBlock
from src.models... | hyena-dna-main | src/tasks/encoders.py |
from typing import Any
import pytorch_lightning as pl
from pytorch_lightning.utilities import rank_zero_only
from pytorch_lightning.utilities.parsing import AttributeDict
class ParamsLog(pl.Callback):
""" Log the number of parameters of the model """
def __init__(
self,
total: bool = True,
... | hyena-dna-main | src/callbacks/params.py |
import torch
from pytorch_lightning import Callback, Trainer, LightningModule
import logging
log = logging.getLogger(__name__) # We want a logger for each process, not just the rank 0
def l2_promote():
import ctypes
_libcudart = ctypes.CDLL('libcudart.so')
# Set device limit on the current device
... | hyena-dna-main | src/callbacks/gpu_affinity.py |
### https://github.com/HazyResearch/transformers/blob/master/src/callbacks/wandb_callbacks.py
import glob
import os
from typing import List
import matplotlib.pyplot as plt
import pandas as pd
import seaborn as sn
import torch
import wandb
from pytorch_lightning import Callback, Trainer
from pytorch_lightning.loggers ... | hyena-dna-main | src/callbacks/wandb.py |
### https://github.com/HazyResearch/transformers/blob/master/src/callbacks/speed_monitor.py
# Adapted from https://pytorch-lightning.readthedocs.io/en/latest/_modules/pytorch_lightning/callbacks/gpu_stats_monitor.html#GPUStatsMonitor
# We only need the speed monitoring, not the GPU monitoring
import time
from typing i... | hyena-dna-main | src/callbacks/timer.py |
r"""
Sequence Length Warmup by Reloading
====================
Change sequence lengths according to a stage schedule. The stage parameters sets the sequence length
and batch size.
TODO (not yet supported):
If batch size is not provided for that stage, calculate the batch size based on the
sequence length reshaping in... | hyena-dna-main | src/callbacks/seqlen_warmup_reload.py |
import pytorch_lightning as pl
from pytorch_lightning.utilities import rank_zero_only
from pytorch_lightning.utilities.parsing import AttributeDict
from omegaconf import OmegaConf
class TrackNorms(pl.Callback):
# TODO do callbacks happen before or after the method in the main LightningModule?
# @rank_zero_onl... | hyena-dna-main | src/callbacks/norms.py |
import numpy as np
from pytorch_lightning.callbacks import Callback
import src.utils as utils
from src.utils import registry
class ProgressiveResizing(Callback):
def __init__(self, stage_params: list):
"""
stage_params is a list of dicts
e.g. stage_params = [
{'resolution': 4... | hyena-dna-main | src/callbacks/progressive_resizing.py |
"""
ET Dataset from Informer Paper.
Dataset: https://github.com/zhouhaoyi/ETDataset
Dataloader: https://github.com/zhouhaoyi/Informer2020
"""
from typing import List
import os
import numpy as np
import pandas as pd
from pandas.tseries import offsets
from pandas.tseries.frequencies import to_offset
import torch
from to... | hyena-dna-main | src/dataloaders/et.py |
from . import et, genomics
from .base import SequenceDataset
| hyena-dna-main | src/dataloaders/__init__.py |
# Adapted from https://github.com/huggingface/transformers/blob/master/examples/pytorch/language-modeling/run_clm.py
# Adapted from https://github.com/HazyResearch/flash-attention/blob/main/training/src/datamodules/language_modeling_hf.py
from pathlib import Path
from typing import Any, List, Union
from torch.utils.dat... | hyena-dna-main | src/dataloaders/genomics.py |
# Adapted from https://github.com/Lightning-AI/lightning/blob/2845e7565dbe6b765ae32870e7d2bc456529c30a/tests/tests_pytorch/utilities/test_auto_restart.py#L1397
from typing import Iterator
import math
import torch
from torch.utils.data import RandomSampler, DistributedSampler
class RandomFaultTolerantSampler(RandomSa... | hyena-dna-main | src/dataloaders/fault_tolerant_sampler.py |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.