File size: 5,110 Bytes
6728bc2 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 |
# https://github.com/comfyanonymous/ComfyUI/blob/v0.3.64/comfy/sd1_clip.py
# https://github.com/comfyanonymous/ComfyUI/blob/v0.3.64/comfy/text_encoders/lumina2.py
from typing import TYPE_CHECKING
if TYPE_CHECKING:
from modules.prompt_parser import SdConditioning
import torch
from backend import memory_management
from backend.text_processing import emphasis, parsing
from modules.shared import opts
class PromptChunk:
def __init__(self):
self.tokens = []
self.multipliers = []
class GemmaTextProcessingEngine:
def __init__(self, text_encoder, tokenizer):
super().__init__()
self.text_encoder = text_encoder
self.tokenizer = tokenizer
self.id_start = 2
self.id_pad = 0
self.intermediate_output = -2
self.layer_norm_hidden_state = False
def tokenize(self, texts):
tokenized = self.tokenizer(texts, truncation=False, add_special_tokens=False)["input_ids"]
return tokenized
def tokenize_line(self, line):
parsed = parsing.parse_prompt_attention(line, self.emphasis.name)
tokenized = self.tokenize([text for text, _ in parsed])
chunks = []
chunk = PromptChunk()
token_count = 0
def next_chunk():
nonlocal token_count
nonlocal chunk
chunk.tokens = [self.id_start] + chunk.tokens
chunk.multipliers = [1.0] + chunk.multipliers
chunks.append(chunk)
chunk = PromptChunk()
for tokens, (text, weight) in zip(tokenized, parsed):
if text == "BREAK" and weight == -1:
next_chunk()
continue
position = 0
while position < len(tokens):
token = tokens[position]
chunk.tokens.append(token)
chunk.multipliers.append(weight)
position += 1
if chunk.tokens or not chunks:
next_chunk()
return chunks, token_count
@staticmethod
def process_template(text: str, negative: bool) -> str:
if "<Prompt Start>" in text:
return text
from modules.shared import opts
if negative:
return "\n".join([opts.neta_template_negative, text])
else:
return "\n".join([opts.neta_template_positive, text])
def __call__(self, texts: "SdConditioning"):
zs = []
cache = {}
self.emphasis = emphasis.get_current_option(opts.emphasis)()
for line in texts:
line = self.process_template(line, texts.is_negative_prompt)
if line in cache:
line_z_values = cache[line]
else:
chunks, token_count = self.tokenize_line(line)
line_z_values = []
# pad all chunks to length of longest chunk
# max_tokens = 0
# for chunk in chunks:
# max_tokens = max(len(chunk.tokens), max_tokens)
for chunk in chunks:
tokens = chunk.tokens
multipliers = chunk.multipliers
# remaining_count = max_tokens - len(tokens)
# if remaining_count > 0:
# tokens += [self.id_pad] * remaining_count
# multipliers += [1.0] * remaining_count
z = self.process_tokens([tokens], [multipliers])[0]
line_z_values.append(z)
cache[line] = line_z_values
zs.extend(line_z_values)
return zs
def process_embeds(self, batch_tokens):
device = memory_management.text_encoder_device()
self.text_encoder.to(device)
embeds_out = []
attention_masks = []
num_tokens = []
for tokens in batch_tokens:
attention_mask = []
tokens_temp = []
eos = False
index = 0
for t in tokens:
token = int(t)
attention_mask.append(0 if eos else 1)
tokens_temp += [token]
if not eos and token == self.id_pad:
eos = True
index += 1
tokens_embed = torch.tensor([tokens_temp], device=device, dtype=torch.long)
tokens_embed = self.text_encoder.get_input_embeddings()(tokens_embed)
index = 0
embeds_out.append(tokens_embed)
attention_masks.append(attention_mask)
num_tokens.append(sum(attention_mask))
return torch.cat(embeds_out), torch.tensor(attention_masks, device=device, dtype=torch.long), num_tokens
def process_tokens(self, batch_tokens, batch_multipliers):
embeds, mask, count = self.process_embeds(batch_tokens)
_, z = self.text_encoder(
None,
attention_mask=mask,
embeds=embeds,
num_tokens=count,
intermediate_output=self.intermediate_output,
final_layer_norm_intermediate=self.layer_norm_hidden_state,
)
return z
|