| # File: candle-main/candle-pyo3/_additional_typing/__init__.py | |
| from typing import Union, Sequence | |
| class Tensor: | |
| def __add__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor': | |
| pass | |
| def __radd__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor': | |
| pass | |
| def __sub__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor': | |
| pass | |
| def __truediv__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor': | |
| pass | |
| def __mul__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor': | |
| pass | |
| def __rmul__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor': | |
| pass | |
| def __richcmp__(self, rhs: Union['Tensor', 'Scalar'], op) -> 'Tensor': | |
| pass | |
| def __getitem__(self, index: Union['Index', 'Tensor', Sequence['Index']]) -> 'Tensor': | |
| pass | |
| def __eq__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor': | |
| pass | |
| def __ne__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor': | |
| pass | |
| def __lt__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor': | |
| pass | |
| def __le__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor': | |
| pass | |
| def __gt__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor': | |
| pass | |
| def __ge__(self, rhs: Union['Tensor', 'Scalar']) -> 'Tensor': | |
| pass | |
| # File: candle-main/candle-pyo3/e5.py | |
| from candle.utils import load_safetensors, save_gguf, load_gguf | |
| from candle.models.bert import BertModel, Config | |
| import json | |
| from candle import Tensor | |
| from tqdm import tqdm | |
| from dataclasses import fields | |
| import os | |
| import time | |
| from huggingface_hub import hf_hub_download | |
| from transformers import BertTokenizer, AutoModel | |
| import torch | |
| if __name__ == '__main__': | |
| model_name = 'intfloat/e5-small-v2' | |
| model_file = hf_hub_download(repo_id=model_name, filename='model.safetensors') | |
| config_file = hf_hub_download(repo_id=model_name, filename='config.json') | |
| tensors = load_safetensors(model_file) | |
| config = Config() | |
| with open(config_file, 'r') as f: | |
| raw_config = json.load(f) | |
| for field in fields(config): | |
| if field.name in raw_config: | |
| setattr(config, field.name, raw_config[field.name]) | |
| model = BertModel(config) | |
| model.load_state_dict(tensors) | |
| hf_model = AutoModel.from_pretrained(model_name) | |
| tokenizer = BertTokenizer.from_pretrained(model_name) | |
| sentences = ['The cat sits outside', 'A man is playing guitar', 'I love pasta', 'The new movie is awesome', 'The cat plays in the garden', 'A woman watches TV', 'The new movie is so great', 'Do you like pizza?'] | |
| def average_pool(last_hidden_states: torch.Tensor, attention_mask: torch.Tensor): | |
| last_hidden = last_hidden_states.masked_fill(~attention_mask[..., None].bool(), 0.0) | |
| return last_hidden.sum(dim=1) / attention_mask.sum(dim=1)[..., None] | |
| tokenized = tokenizer(sentences, padding=True) | |
| tokens = Tensor(tokenized['input_ids']) | |
| token_type_ids = Tensor(tokenized['token_type_ids']) | |
| attention_mask = Tensor(tokenized['attention_mask']) | |
| (encoder_out, _) = model.forward(tokens, token_type_ids, attention_mask=attention_mask) | |
| hf_tokenized = tokenizer(sentences, padding=True, return_tensors='pt') | |
| hf_result = hf_model(**hf_tokenized)['last_hidden_state'] | |
| hf_pooled = average_pool(hf_result, hf_tokenized['attention_mask']) | |
| candle_pooled = average_pool(torch.tensor(encoder_out.values()), hf_tokenized['attention_mask']) | |
| loss = torch.nn.L1Loss() | |
| error = loss(hf_pooled, candle_pooled).mean().item() | |
| print(f'Mean error between torch-reference and candle: {error}') | |
| quantized_tensors = {} | |
| for (name, tensor) in tqdm(tensors.items(), desc='Quantizing tensors to 5-Bit'): | |
| if name.endswith('weight') and ('attention' in name or 'intermediate' in name or 'output' in name): | |
| if tensor.shape[-1] % 256 == 0: | |
| new_tensor = tensor.quantize('q4k') | |
| else: | |
| new_tensor = tensor.quantize('q5_0') | |
| quantized_tensors[name] = new_tensor | |
| else: | |
| quantized_tensors[name] = tensor.quantize('q8_0') | |
| print(f'Saving quantized tensors') | |
| config_to_save = {k: v for (k, v) in config.__dict__.items() if v is not None} | |
| quantized_model_file = 'e5_small.gguf' | |
| save_gguf(quantized_model_file, quantized_tensors, config_to_save) | |
| file_size_mb = os.path.getsize(model_file) / 1024 / 1024 | |
| file_size_mb_compressed = os.path.getsize(quantized_model_file) / 1024 / 1024 | |
| print(f'Compressed model from {file_size_mb:.2f} MB to {file_size_mb_compressed:.2f} MB') | |
| (tensors, raw_config) = load_gguf(quantized_model_file) | |
| config = Config() | |
| for field in fields(config): | |
| if field.name in raw_config: | |
| setattr(config, field.name, raw_config[field.name]) | |
| model = BertModel(config) | |
| model.load_state_dict(tensors, strict=False) | |
| (encoder_out_2, pooled_output_2) = model.forward(tokens, token_type_ids) | |
| (encoder_out_2, pooled_output_2) = (encoder_out_2.to_device('cpu'), pooled_output_2.to_device('cpu')) | |
| candle_pooled_2 = average_pool(torch.tensor(encoder_out_2.values()), hf_tokenized['attention_mask']) | |
| error = loss(hf_pooled, candle_pooled_2).mean().item() | |
| print(f'Mean error between torch-reference and quantized-candle: {error}') | |
| # File: candle-main/candle-pyo3/py_src/candle/__init__.py | |
| import logging | |
| try: | |
| from .candle import * | |
| except ImportError as e: | |
| logging.warning('DLLs were not bundled with this package. Trying to locate them...') | |
| import os | |
| import platform | |
| def locate_cuda_dlls(): | |
| logging.warning('Locating CUDA DLLs...') | |
| cuda_path = os.environ.get('CUDA_PATH', None) | |
| if cuda_path: | |
| logging.warning(f'Found CUDA_PATH environment variable: {cuda_path}') | |
| if platform.system() == 'Windows': | |
| cuda_path = os.path.join(cuda_path, 'bin') | |
| else: | |
| cuda_path = os.path.join(cuda_path, 'lib64') | |
| logging.warning(f'Adding {cuda_path} to DLL search path...') | |
| os.add_dll_directory(cuda_path) | |
| else: | |
| logging.warning('CUDA_PATH environment variable not found!') | |
| def locate_mkl_dlls(): | |
| oneapi_root = os.environ.get('ONEAPI_ROOT', None) | |
| if oneapi_root: | |
| if platform.system() == 'Windows': | |
| mkl_path = os.path.join(oneapi_root, 'compiler', 'latest', 'windows', 'redist', 'intel64_win', 'compiler') | |
| else: | |
| mkl_path = os.path.join(oneapi_root, 'mkl', 'latest', 'lib', 'intel64') | |
| logging.warning(f'Adding {mkl_path} to DLL search path...') | |
| os.add_dll_directory(mkl_path) | |
| else: | |
| logging.warning('ONEAPI_ROOT environment variable not found!') | |
| locate_cuda_dlls() | |
| locate_mkl_dlls() | |
| try: | |
| from .candle import * | |
| except ImportError as inner_e: | |
| raise ImportError('Could not locate DLLs. Please check the documentation for more information.') | |
| __doc__ = candle.__doc__ | |
| if hasattr(candle, '__all__'): | |
| __all__ = candle.__all__ | |
| # File: candle-main/candle-pyo3/py_src/candle/models/bert.py | |
| from dataclasses import dataclass | |
| from typing import Optional | |
| from candle.nn import Module, Embedding, LayerNorm, Linear, ModuleList | |
| from candle import Tensor | |
| import candle | |
| import candle.functional as F | |
| from typing import Tuple, Optional | |
| @dataclass | |
| class Config: | |
| vocab_size: int = 30522 | |
| hidden_size: int = 768 | |
| num_hidden_layers: int = 12 | |
| num_attention_heads: int = 12 | |
| intermediate_size: int = 3072 | |
| hidden_act: str = 'gelu' | |
| hidden_dropout_prob: float = 0.1 | |
| max_position_embeddings: int = 512 | |
| type_vocab_size: int = 2 | |
| initializer_range: float = 0.02 | |
| layer_norm_eps: float = 1e-12 | |
| pad_token_id: int = 0 | |
| position_embedding_type: str = 'absolute' | |
| use_cache: bool = True | |
| classifier_dropout: Optional[float] = None | |
| model_type: Optional[str] = 'bert' | |
| class BertSelfAttention(Module): | |
| def __init__(self, config: Config) -> None: | |
| super().__init__() | |
| self.num_attention_heads = config.num_attention_heads | |
| self.attention_head_size = int(config.hidden_size / self.num_attention_heads) | |
| all_head_size = int(config.num_attention_heads * self.attention_head_size) | |
| hidden_size = config.hidden_size | |
| self.query = Linear(hidden_size, all_head_size) | |
| self.key = Linear(hidden_size, all_head_size) | |
| self.value = Linear(hidden_size, all_head_size) | |
| def transpose_for_scores(self, x: Tensor) -> Tensor: | |
| new_x_shape = x.shape[:-1] + (self.num_attention_heads, self.attention_head_size) | |
| x = x.reshape(new_x_shape).transpose(1, 2) | |
| return x.contiguous() | |
| def forward(self, hidden_states: Tensor, attention_mask=None) -> Tensor: | |
| query = self.query.forward(hidden_states) | |
| key = self.key.forward(hidden_states) | |
| value = self.value.forward(hidden_states) | |
| query = self.transpose_for_scores(query) | |
| key = self.transpose_for_scores(key) | |
| value = self.transpose_for_scores(value) | |
| attention_scores = query.matmul(key.t()) | |
| attention_scores = attention_scores / float(self.attention_head_size) ** 0.5 | |
| if attention_mask is not None: | |
| (b_size, _, _, last_dim) = attention_scores.shape | |
| attention_scores = attention_scores.broadcast_add(attention_mask.reshape((b_size, 1, 1, last_dim))) | |
| attention_probs = F.softmax(attention_scores, dim=-1) | |
| context_layer = attention_probs.matmul(value) | |
| context_layer = context_layer.transpose(1, 2).contiguous() | |
| context_layer = context_layer.flatten_from(-2) | |
| return context_layer | |
| class BertSelfOutput(Module): | |
| def __init__(self, config: Config) -> None: | |
| super().__init__() | |
| self.dense = Linear(config.hidden_size, config.hidden_size) | |
| self.LayerNorm = LayerNorm(config.hidden_size, eps=config.layer_norm_eps) | |
| def forward(self, hidden_states: Tensor, input_tensor: Tensor) -> Tensor: | |
| hidden_states = self.dense.forward(hidden_states) | |
| return self.LayerNorm.forward(hidden_states + input_tensor) | |
| class BertAttention(Module): | |
| def __init__(self, config: Config) -> None: | |
| super().__init__() | |
| self.self = BertSelfAttention(config) | |
| self.output = BertSelfOutput(config) | |
| def forward(self, hidden_states: Tensor, attention_mask: None) -> Tensor: | |
| self_outputs = self.self.forward(hidden_states, attention_mask=attention_mask) | |
| attention_output = self.output.forward(self_outputs, hidden_states) | |
| return attention_output | |
| class BertIntermediate(Module): | |
| def __init__(self, config: Config) -> None: | |
| super().__init__() | |
| self.dense = Linear(config.hidden_size, config.intermediate_size) | |
| self.act = F.gelu if config.hidden_act == 'gelu' else F.relu | |
| def forward(self, hidden_states: Tensor) -> Tensor: | |
| hidden_states = self.dense.forward(hidden_states) | |
| return self.act(hidden_states) | |
| class BertOutput(Module): | |
| def __init__(self, config: Config) -> None: | |
| super().__init__() | |
| self.dense = Linear(config.intermediate_size, config.hidden_size) | |
| self.LayerNorm = LayerNorm(config.hidden_size, eps=config.layer_norm_eps) | |
| def forward(self, hidden_states: Tensor, input_tensor: Tensor) -> Tensor: | |
| hidden_states = self.dense.forward(hidden_states) | |
| return self.LayerNorm.forward(hidden_states + input_tensor) | |
| class BertLayer(Module): | |
| def __init__(self, config: Config) -> None: | |
| super().__init__() | |
| self.attention = BertAttention(config) | |
| self.intermediate = BertIntermediate(config) | |
| self.output = BertOutput(config) | |
| def forward(self, hidden_states: Tensor, attention_mask=None) -> Tensor: | |
| attention_output = self.attention.forward(hidden_states, attention_mask=attention_mask) | |
| intermediate_output = self.intermediate.forward(attention_output) | |
| layer_output = self.output.forward(intermediate_output, attention_output) | |
| return layer_output | |
| class BertEncoder(Module): | |
| def __init__(self, config: Config) -> None: | |
| super().__init__() | |
| self.layer = ModuleList() | |
| for _ in range(config.num_hidden_layers): | |
| self.layer.append(BertLayer(config)) | |
| def forward(self, hidden_states: Tensor, attention_mask=None) -> Tensor: | |
| for l in self.layer: | |
| hidden_states = l.forward(hidden_states, attention_mask=attention_mask) | |
| return hidden_states | |
| class BertEmbeddings(Module): | |
| def __init__(self, config: Config) -> None: | |
| super().__init__() | |
| self.word_embeddings = Embedding(config.vocab_size, config.hidden_size) | |
| self.position_embeddings = Embedding(config.max_position_embeddings, config.hidden_size) | |
| self.token_type_embeddings = Embedding(config.type_vocab_size, config.hidden_size) | |
| self.LayerNorm = LayerNorm(config.hidden_size, eps=config.layer_norm_eps) | |
| self.position_ids = candle.Tensor(list(range(config.max_position_embeddings))).reshape((1, config.max_position_embeddings)) | |
| def forward(self, input_ids: Tensor, token_type_ids: Tensor) -> Tensor: | |
| (_batch_size, seq_len) = input_ids.shape | |
| input_embeddings = self.word_embeddings.forward(input_ids) | |
| token_type_embeddings = self.token_type_embeddings.forward(token_type_ids) | |
| embeddings: Tensor = input_embeddings + token_type_embeddings | |
| position_ids = list(range(seq_len)) | |
| position_ids = Tensor(position_ids).to_dtype(input_ids.dtype).to_device(input_ids.device) | |
| embeddings = embeddings.broadcast_add(self.position_embeddings.forward(position_ids)) | |
| embeddings = self.LayerNorm(embeddings) | |
| return embeddings | |
| class BertPooler(Module): | |
| def __init__(self, config: Config) -> None: | |
| super().__init__() | |
| self.dense = Linear(config.hidden_size, config.hidden_size) | |
| self.activation = F.tanh | |
| def forward(self, hidden_states: Tensor) -> Tensor: | |
| first_token_tensor = hidden_states[:, 0] | |
| pooled_output = self.dense.forward(first_token_tensor) | |
| pooled_output = self.activation(pooled_output) | |
| return pooled_output | |
| def masked_fill(on_false: float, mask: Tensor, on_true: float): | |
| shape = mask.shape | |
| on_true = candle.tensor(on_true).broadcast_as(shape) | |
| on_false = candle.tensor(on_false).broadcast_as(shape) | |
| return mask.where_cond(on_true, on_false) | |
| class BertModel(Module): | |
| def __init__(self, config: Config, add_pooling_layer=True) -> None: | |
| super().__init__() | |
| self.config = config | |
| self.embeddings = BertEmbeddings(config) | |
| self.encoder = BertEncoder(config) | |
| self.pooler = BertPooler(config) if add_pooling_layer else None | |
| def forward(self, input_ids: Tensor, token_type_ids: Tensor, attention_mask=None) -> Tuple[Tensor, Optional[Tensor]]: | |
| if attention_mask is not None: | |
| attention_mask = masked_fill(float('-inf'), attention_mask, 1.0) | |
| embeddings = self.embeddings.forward(input_ids, token_type_ids) | |
| encoder_out = self.encoder.forward(embeddings, attention_mask=attention_mask) | |
| pooled_output = self.pooler(encoder_out) if self.pooler is not None else None | |
| return (encoder_out, pooled_output) | |
| # File: candle-main/candle-pyo3/py_src/candle/models/llama.py | |
| import candle | |
| from typing import Dict, Tuple, Any | |
| from candle import Tensor, QTensor, utils, nn | |
| from candle.nn import Module, ModuleList | |
| def masked_fill(on_false: Tensor, mask: Tensor, on_true: Tensor): | |
| shape = mask.shape | |
| on_true = candle.tensor(on_true).broadcast_as(shape) | |
| return mask.where_cond(on_true, on_false) | |
| def precompute_freqs_cis(hparams: Dict[str, Any], freq_base: float, max_seq_len: int): | |
| head_dim = hparams['n_embd'] // hparams['n_head'] | |
| theta = [1.0 / freq_base ** (i / head_dim) for i in range(0, head_dim, 2)] | |
| theta = candle.tensor(theta) | |
| idx_theta = [float(i) for i in range(max_seq_len)] | |
| idx_theta = candle.tensor(idx_theta).reshape((max_seq_len, 1)) | |
| m = idx_theta.matmul(theta.unsqueeze(0)) | |
| return (m.cos(), m.sin()) | |
| class RmsNorm(Module): | |
| def __init__(self, qtensor: QTensor): | |
| super().__init__() | |
| self.weight = qtensor.dequantize() | |
| def forward(self, x: Tensor) -> Tensor: | |
| (b_size, seq_len, hidden_size) = x.shape | |
| norm_x = x.sqr().sum_keepdim(2) / hidden_size | |
| x_normed = x.broadcast_div((norm_x + 1e-05).sqrt()) | |
| return x_normed.broadcast_mul(self.weight) | |
| class QuantizedLayer(Module): | |
| def __init__(self, layer_idx: int, hparams: Dict[str, Any], all_tensors: Dict[str, QTensor], cos_sin: Tuple[Tensor, Tensor]): | |
| super().__init__() | |
| p = f'layers.{layer_idx}' | |
| self.attention_wq = all_tensors[f'{p}.attention.wq.weight'] | |
| self.attention_wk = all_tensors[f'{p}.attention.wk.weight'] | |
| self.attention_wv = all_tensors[f'{p}.attention.wv.weight'] | |
| self.attention_wo = all_tensors[f'{p}.attention.wo.weight'] | |
| self.ffw1 = all_tensors[f'{p}.feed_forward.w1.weight'] | |
| self.ffw2 = all_tensors[f'{p}.feed_forward.w2.weight'] | |
| self.ffw3 = all_tensors[f'{p}.feed_forward.w3.weight'] | |
| self.attn_norm = RmsNorm(all_tensors[f'{p}.attention_norm.weight']) | |
| self.ffn_norm = RmsNorm(all_tensors[f'{p}.ffn_norm.weight']) | |
| self.n_head = hparams['n_head'] | |
| self.n_kv_head = self.n_head | |
| self.head_dim = hparams['n_embd'] // self.n_head | |
| self.kv_cache = None | |
| self.cos = cos_sin[0] | |
| self.sin = cos_sin[1] | |
| self._non_persistent_buffers_set.add('cos') | |
| self._non_persistent_buffers_set.add('sin') | |
| def forward(self, x: Tensor, mask: Tensor, index_pos: int) -> Tensor: | |
| residual = x | |
| x = self.attn_norm(x) | |
| attn = self.forward_attn(x, mask, index_pos) | |
| x = attn + residual | |
| residual = x | |
| x = self.ffn_norm(x) | |
| w1 = self.ffw1.matmul_t(x) | |
| w3 = self.ffw3.matmul_t(x) | |
| mlp = self.ffw2.matmul_t(nn.silu(w1) * w3) | |
| return mlp + residual | |
| def forward_attn(self, x: Tensor, mask: Tensor, index_pos: int): | |
| (b_size, seq_len, n_embd) = x.shape | |
| q = self.attention_wq.matmul_t(x) | |
| k = self.attention_wk.matmul_t(x) | |
| v = self.attention_wv.matmul_t(x) | |
| q = q.reshape((b_size, seq_len, self.n_head, self.head_dim)).transpose(1, 2) | |
| k = k.reshape((b_size, seq_len, self.n_kv_head, self.head_dim)).transpose(1, 2) | |
| v = v.reshape((b_size, seq_len, self.n_kv_head, self.head_dim)).transpose(1, 2) | |
| q = self.apply_rotary_emb(q, index_pos) | |
| k = self.apply_rotary_emb(k, index_pos) | |
| if self.kv_cache is not None and index_pos > 0: | |
| (prev_k, prev_v) = self.kv_cache | |
| k = candle.cat([prev_k, k], 2).contiguous() | |
| v = candle.cat([prev_v, v], 2).contiguous() | |
| self.kv_cache = (k, v) | |
| att = q.matmul(k.t()) / self.head_dim ** 0.5 | |
| mask = mask.broadcast_as(att.shape) | |
| att = masked_fill(att, mask, float('-inf')) | |
| att = nn.softmax(att, -1) | |
| y = att.matmul(v.contiguous()) | |
| y = y.transpose(1, 2).reshape((b_size, seq_len, n_embd)) | |
| return self.attention_wo.matmul_t(y) | |
| def apply_rotary_emb(self, x: Tensor, index_pos: int): | |
| (b_size, n_head, seq_len, n_embd) = x.shape | |
| cos = self.cos.narrow(0, index_pos, seq_len).reshape((seq_len, n_embd // 2, 1)) | |
| sin = self.sin.narrow(0, index_pos, seq_len).reshape((seq_len, n_embd // 2, 1)) | |
| x = x.reshape((b_size, n_head, seq_len, n_embd // 2, 2)) | |
| x0 = x.narrow(-1, 0, 1) | |
| x1 = x.narrow(-1, 1, 1) | |
| y0 = x0.broadcast_mul(cos) - x1.broadcast_mul(sin) | |
| y1 = x0.broadcast_mul(sin) + x1.broadcast_mul(cos) | |
| rope = candle.cat([y0, y1], -1) | |
| return rope.flatten_from(-2) | |
| class QuantizedLlama(Module): | |
| def __init__(self, hparams: Dict[str, Any], all_tensors: Dict[str, QTensor]): | |
| super().__init__() | |
| self.tok_embeddings = all_tensors['tok_embeddings.weight'].dequantize() | |
| self.norm = RmsNorm(all_tensors['norm.weight']) | |
| self.output = all_tensors['output.weight'] | |
| self.layers = ModuleList() | |
| rope_freq = hparams.get('rope_freq', 10000.0) | |
| cos_sin = precompute_freqs_cis(hparams, rope_freq, hparams['context_length']) | |
| for layer_idx in range(hparams['n_layer']): | |
| layer = QuantizedLayer(layer_idx, hparams, all_tensors, cos_sin) | |
| self.layers.append(layer) | |
| def forward(self, token: Tensor, index_pos: int) -> Tensor: | |
| (b_size, seq_len) = token.shape | |
| (vocab_size, hidden_size) = self.tok_embeddings.shape | |
| token = token.reshape((b_size * seq_len,)) | |
| x = self.tok_embeddings.index_select(token, 0) | |
| x = x.reshape((b_size, seq_len, hidden_size)) | |
| mask = [int(j > i) for j in range(seq_len) for i in range(seq_len)] | |
| mask = candle.tensor(mask).reshape((seq_len, seq_len)) | |
| for layer in self.layers: | |
| x = layer(x, mask, index_pos) | |
| x = self.norm(x) | |
| x = x.narrow(1, -1, 1).squeeze(1) | |
| x = self.output.matmul_t(x) | |
| return x | |
| # File: candle-main/candle-pyo3/py_src/candle/nn/container.py | |
| from .module import Module | |
| from typing import Any, Dict, Iterable, Iterator, Mapping, Optional, overload, Tuple, TypeVar, Union | |
| from collections import OrderedDict, abc as container_abcs | |
| import operator | |
| from itertools import chain, islice | |
| __all__ = ['Sequential', 'ModuleList', 'ModuleDict'] | |
| T = TypeVar('T', bound=Module) | |
| def _addindent(s_: str, numSpaces: int): | |
| s = s_.split('\n') | |
| if len(s) == 1: | |
| return s_ | |
| first = s.pop(0) | |
| s = [numSpaces * ' ' + line for line in s] | |
| s = '\n'.join(s) | |
| s = first + '\n' + s | |
| return s | |
| class Sequential(Module): | |
| _modules: Dict[str, Module] | |
| @overload | |
| def __init__(self, *args: Module) -> None: | |
| ... | |
| @overload | |
| def __init__(self, arg: 'OrderedDict[str, Module]') -> None: | |
| ... | |
| def __init__(self, *args): | |
| super().__init__() | |
| if len(args) == 1 and isinstance(args[0], OrderedDict): | |
| for (key, module) in args[0].items(): | |
| self.add_module(key, module) | |
| else: | |
| for (idx, module) in enumerate(args): | |
| self.add_module(str(idx), module) | |
| def _get_item_by_idx(self, iterator, idx) -> T: | |
| size = len(self) | |
| idx = operator.index(idx) | |
| if not -size <= idx < size: | |
| raise IndexError('index {} is out of range'.format(idx)) | |
| idx %= size | |
| return next(islice(iterator, idx, None)) | |
| def __getitem__(self, idx: Union[slice, int]) -> Union['Sequential', T]: | |
| if isinstance(idx, slice): | |
| return self.__class__(OrderedDict(list(self._modules.items())[idx])) | |
| else: | |
| return self._get_item_by_idx(self._modules.values(), idx) | |
| def __setitem__(self, idx: int, module: Module) -> None: | |
| key: str = self._get_item_by_idx(self._modules.keys(), idx) | |
| return setattr(self, key, module) | |
| def __delitem__(self, idx: Union[slice, int]) -> None: | |
| if isinstance(idx, slice): | |
| for key in list(self._modules.keys())[idx]: | |
| delattr(self, key) | |
| else: | |
| key = self._get_item_by_idx(self._modules.keys(), idx) | |
| delattr(self, key) | |
| str_indices = [str(i) for i in range(len(self._modules))] | |
| self._modules = OrderedDict(list(zip(str_indices, self._modules.values()))) | |
| def __len__(self) -> int: | |
| return len(self._modules) | |
| def __add__(self, other) -> 'Sequential': | |
| if isinstance(other, Sequential): | |
| ret = Sequential() | |
| for layer in self: | |
| ret.append(layer) | |
| for layer in other: | |
| ret.append(layer) | |
| return ret | |
| else: | |
| raise ValueError('add operator supports only objects of Sequential class, but {} is given.'.format(str(type(other)))) | |
| def pop(self, key: Union[int, slice]) -> Module: | |
| v = self[key] | |
| del self[key] | |
| return v | |
| def __iadd__(self, other) -> 'Sequential': | |
| if isinstance(other, Sequential): | |
| offset = len(self) | |
| for (i, module) in enumerate(other): | |
| self.add_module(str(i + offset), module) | |
| return self | |
| else: | |
| raise ValueError('add operator supports only objects of Sequential class, but {} is given.'.format(str(type(other)))) | |
| def __mul__(self, other: int) -> 'Sequential': | |
| if not isinstance(other, int): | |
| raise TypeError(f'unsupported operand type(s) for *: {type(self)} and {type(other)}') | |
| elif other <= 0: | |
| raise ValueError(f'Non-positive multiplication factor {other} for {type(self)}') | |
| else: | |
| combined = Sequential() | |
| offset = 0 | |
| for _ in range(other): | |
| for module in self: | |
| combined.add_module(str(offset), module) | |
| offset += 1 | |
| return combined | |
| def __rmul__(self, other: int) -> 'Sequential': | |
| return self.__mul__(other) | |
| def __imul__(self, other: int) -> 'Sequential': | |
| if not isinstance(other, int): | |
| raise TypeError(f'unsupported operand type(s) for *: {type(self)} and {type(other)}') | |
| elif other <= 0: | |
| raise ValueError(f'Non-positive multiplication factor {other} for {type(self)}') | |
| else: | |
| len_original = len(self) | |
| offset = len(self) | |
| for _ in range(other - 1): | |
| for i in range(len_original): | |
| self.add_module(str(i + offset), self._modules[str(i)]) | |
| offset += len_original | |
| return self | |
| def __dir__(self): | |
| keys = super().__dir__() | |
| keys = [key for key in keys if not key.isdigit()] | |
| return keys | |
| def __iter__(self) -> Iterator[Module]: | |
| return iter(self._modules.values()) | |
| def forward(self, input): | |
| for module in self: | |
| input = module(input) | |
| return input | |
| def append(self, module: Module) -> 'Sequential': | |
| self.add_module(str(len(self)), module) | |
| return self | |
| def insert(self, index: int, module: Module) -> 'Sequential': | |
| if not isinstance(module, Module): | |
| raise AssertionError('module should be of type: {}'.format(Module)) | |
| n = len(self._modules) | |
| if not -n <= index <= n: | |
| raise IndexError('Index out of range: {}'.format(index)) | |
| if index < 0: | |
| index += n | |
| for i in range(n, index, -1): | |
| self._modules[str(i)] = self._modules[str(i - 1)] | |
| self._modules[str(index)] = module | |
| return self | |
| def extend(self, sequential) -> 'Sequential': | |
| for layer in sequential: | |
| self.append(layer) | |
| return self | |
| class ModuleList(Module): | |
| _modules: Dict[str, Module] | |
| def __init__(self, modules: Optional[Iterable[Module]]=None) -> None: | |
| super().__init__() | |
| if modules is not None: | |
| self += modules | |
| def _get_abs_string_index(self, idx): | |
| idx = operator.index(idx) | |
| if not -len(self) <= idx < len(self): | |
| raise IndexError('index {} is out of range'.format(idx)) | |
| if idx < 0: | |
| idx += len(self) | |
| return str(idx) | |
| def __getitem__(self, idx: Union[int, slice]) -> Union[Module, 'ModuleList']: | |
| if isinstance(idx, slice): | |
| return self.__class__(list(self._modules.values())[idx]) | |
| else: | |
| return self._modules[self._get_abs_string_index(idx)] | |
| def __setitem__(self, idx: int, module: Module) -> None: | |
| idx = self._get_abs_string_index(idx) | |
| return setattr(self, str(idx), module) | |
| def __delitem__(self, idx: Union[int, slice]) -> None: | |
| if isinstance(idx, slice): | |
| for k in range(len(self._modules))[idx]: | |
| delattr(self, str(k)) | |
| else: | |
| delattr(self, self._get_abs_string_index(idx)) | |
| str_indices = [str(i) for i in range(len(self._modules))] | |
| self._modules = OrderedDict(list(zip(str_indices, self._modules.values()))) | |
| def __len__(self) -> int: | |
| return len(self._modules) | |
| def __iter__(self) -> Iterator[Module]: | |
| return iter(self._modules.values()) | |
| def __iadd__(self, modules: Iterable[Module]) -> 'ModuleList': | |
| return self.extend(modules) | |
| def __add__(self, other: Iterable[Module]) -> 'ModuleList': | |
| combined = ModuleList() | |
| for (i, module) in enumerate(chain(self, other)): | |
| combined.add_module(str(i), module) | |
| return combined | |
| def __repr__(self): | |
| list_of_reprs = [repr(item) for item in self] | |
| if len(list_of_reprs) == 0: | |
| return self._get_name() + '()' | |
| start_end_indices = [[0, 0]] | |
| repeated_blocks = [list_of_reprs[0]] | |
| for (i, r) in enumerate(list_of_reprs[1:], 1): | |
| if r == repeated_blocks[-1]: | |
| start_end_indices[-1][1] += 1 | |
| continue | |
| start_end_indices.append([i, i]) | |
| repeated_blocks.append(r) | |
| lines = [] | |
| main_str = self._get_name() + '(' | |
| for ((start_id, end_id), b) in zip(start_end_indices, repeated_blocks): | |
| local_repr = f'({start_id}): {b}' | |
| if start_id != end_id: | |
| n = end_id - start_id + 1 | |
| local_repr = f'({start_id}-{end_id}): {n} x {b}' | |
| local_repr = _addindent(local_repr, 2) | |
| lines.append(local_repr) | |
| main_str += '\n ' + '\n '.join(lines) + '\n' | |
| main_str += ')' | |
| return main_str | |
| def __dir__(self): | |
| keys = super().__dir__() | |
| keys = [key for key in keys if not key.isdigit()] | |
| return keys | |
| def insert(self, index: int, module: Module) -> None: | |
| for i in range(len(self._modules), index, -1): | |
| self._modules[str(i)] = self._modules[str(i - 1)] | |
| self._modules[str(index)] = module | |
| def append(self, module: Module) -> 'ModuleList': | |
| self.add_module(str(len(self)), module) | |
| return self | |
| def pop(self, key: Union[int, slice]) -> Module: | |
| v = self[key] | |
| del self[key] | |
| return v | |
| def extend(self, modules: Iterable[Module]) -> 'ModuleList': | |
| if not isinstance(modules, container_abcs.Iterable): | |
| raise TypeError('ModuleList.extend should be called with an iterable, but got ' + type(modules).__name__) | |
| offset = len(self) | |
| for (i, module) in enumerate(modules): | |
| self.add_module(str(offset + i), module) | |
| return self | |
| class ModuleDict(Module): | |
| _modules: Dict[str, Module] | |
| def __init__(self, modules: Optional[Mapping[str, Module]]=None) -> None: | |
| super().__init__() | |
| if modules is not None: | |
| self.update(modules) | |
| def __getitem__(self, key: str) -> Module: | |
| return self._modules[key] | |
| def __setitem__(self, key: str, module: Module) -> None: | |
| self.add_module(key, module) | |
| def __delitem__(self, key: str) -> None: | |
| del self._modules[key] | |
| def __len__(self) -> int: | |
| return len(self._modules) | |
| def __iter__(self) -> Iterator[str]: | |
| return iter(self._modules) | |
| def __contains__(self, key: str) -> bool: | |
| return key in self._modules | |
| def clear(self) -> None: | |
| self._modules.clear() | |
| def pop(self, key: str) -> Module: | |
| v = self[key] | |
| del self[key] | |
| return v | |
| def keys(self) -> Iterable[str]: | |
| return self._modules.keys() | |
| def items(self) -> Iterable[Tuple[str, Module]]: | |
| return self._modules.items() | |
| def values(self) -> Iterable[Module]: | |
| return self._modules.values() | |
| def update(self, modules: Mapping[str, Module]) -> None: | |
| if not isinstance(modules, container_abcs.Iterable): | |
| raise TypeError('ModuleDict.update should be called with an iterable of key/value pairs, but got ' + type(modules).__name__) | |
| if isinstance(modules, (OrderedDict, ModuleDict, container_abcs.Mapping)): | |
| for (key, module) in modules.items(): | |
| self[key] = module | |
| else: | |
| for (j, m) in enumerate(modules): | |
| if not isinstance(m, container_abcs.Iterable): | |
| raise TypeError('ModuleDict update sequence element #' + str(j) + ' should be Iterable; is' + type(m).__name__) | |
| if not len(m) == 2: | |
| raise ValueError('ModuleDict update sequence element #' + str(j) + ' has length ' + str(len(m)) + '; 2 is required') | |
| self[m[0]] = m[1] | |
| # File: candle-main/candle-pyo3/py_src/candle/nn/linear.py | |
| import math | |
| from typing import Any | |
| import candle | |
| from candle import Tensor | |
| from .module import Module | |
| class Identity(Module): | |
| def __init__(self, *args: Any, **kwargs: Any) -> None: | |
| super().__init__() | |
| def forward(self, input: Tensor) -> Tensor: | |
| return input | |
| class Linear(Module): | |
| __constants__ = ['in_features', 'out_features'] | |
| in_features: int | |
| out_features: int | |
| weight: Tensor | |
| def __init__(self, in_features: int, out_features: int, bias: bool=True, device=None, dtype=None) -> None: | |
| factory_kwargs = {'device': device, 'dtype': dtype} | |
| super().__init__() | |
| self._quantizable_buffers.add('weight') | |
| self.in_features = in_features | |
| self.out_features = out_features | |
| self.weight = candle.ones((out_features, in_features), **factory_kwargs) | |
| if bias: | |
| self.bias = candle.zeros((out_features,), **factory_kwargs) | |
| else: | |
| self.bias = None | |
| def forward(self, x: Tensor) -> Tensor: | |
| dims = x.shape | |
| last_dim = dims[-1] | |
| if isinstance(self.weight, candle.QTensor): | |
| if len(dims) < 3: | |
| matmul_result = self.weight.matmul_t(x).broadcast_add(self.bias) | |
| elif len(dims) == 3: | |
| (b, n, m) = dims | |
| output_shape = (b, n, self.out_features) | |
| re = x.reshape((b * n, m)) | |
| matmul_result = self.weight.matmul_t(re).reshape(output_shape) | |
| else: | |
| raise NotImplementedError("'QTensor.matmul_t' is not implemented for more than 3 dimensions") | |
| if self.bias: | |
| return matmul_result.broadcast_add(self.bias) | |
| else: | |
| if self.weight.shape[-1] == last_dim and len(dims) < 3: | |
| w = self.weight.t() | |
| else: | |
| batch_size = dims[0] | |
| w = self.weight.broadcast_left((batch_size,)).t() | |
| x = x.matmul(w) | |
| if self.bias is not None: | |
| x = x.broadcast_add(self.bias) | |
| return x | |
| def extra_repr(self) -> str: | |
| return f'in_features={self.in_features}, out_features={self.out_features}, bias={self.bias is not None}' | |
| # File: candle-main/candle-pyo3/py_src/candle/nn/module.py | |
| from candle import Tensor, QTensor, DType | |
| from typing import Dict, Tuple, Any, Optional, Union, Iterator, Set, overload, Mapping, TypeVar, List | |
| from collections import OrderedDict, namedtuple | |
| TensorLike = Union[Tensor, QTensor] | |
| T = TypeVar('T', bound='Module') | |
| class _IncompatibleKeys(namedtuple('IncompatibleKeys', ['missing_keys', 'unexpected_keys'])): | |
| def __repr__(self): | |
| if not self.missing_keys and (not self.unexpected_keys): | |
| return '<All keys matched successfully>' | |
| return super().__repr__() | |
| __str__ = __repr__ | |
| class Module: | |
| _modules: Dict[str, Optional['Module']] | |
| _buffers: Dict[str, Optional[TensorLike]] | |
| _non_persistent_buffers_set: Set[str] | |
| _quantizable_buffers: Set[str] | |
| _version: int = 1 | |
| def __init__(self, *args, **kwargs) -> None: | |
| super().__setattr__('_modules', OrderedDict()) | |
| super().__setattr__('_buffers', OrderedDict()) | |
| super().__setattr__('_non_persistent_buffers_set', set()) | |
| super().__setattr__('_quantizable_buffers', set()) | |
| def __call__(self, *input): | |
| return self.forward(*input) | |
| def forward(self, *input): | |
| pass | |
| def children(self) -> Iterator['Module']: | |
| for (name, module) in self.named_children(): | |
| yield module | |
| def named_children(self) -> Iterator[Tuple[str, 'Module']]: | |
| memo = set() | |
| for (name, module) in self._modules.items(): | |
| if module is not None and module not in memo: | |
| memo.add(module) | |
| yield (name, module) | |
| def add_module(self, name: str, module: Optional['Module']) -> None: | |
| if not isinstance(module, Module) and module is not None: | |
| raise TypeError(f'{str(module)} is not a Module subclass') | |
| elif not isinstance(name, str): | |
| raise TypeError(f'module name should be a string. Got {name}') | |
| elif hasattr(self, name) and name not in self._modules: | |
| raise KeyError(f"attribute '{name}' already exists") | |
| elif '.' in name: | |
| raise KeyError(f"""module name can't contain ".", got: {name}""") | |
| elif name == '': | |
| raise KeyError('module name can\'t be empty string ""') | |
| self._modules[name] = module | |
| def register_module(self, name: str, module: Optional['Module']) -> None: | |
| self.add_module(name, module) | |
| def modules(self) -> Iterator['Module']: | |
| for (_, module) in self.named_modules(): | |
| yield module | |
| def named_modules(self, memo: Optional[Set['Module']]=None, prefix: str='', remove_duplicate: bool=True): | |
| if memo is None: | |
| memo = set() | |
| if self not in memo: | |
| if remove_duplicate: | |
| memo.add(self) | |
| yield (prefix, self) | |
| for (name, module) in self._modules.items(): | |
| if module is None: | |
| continue | |
| submodule_prefix = prefix + ('.' if prefix else '') + name | |
| for m in module.named_modules(memo, submodule_prefix, remove_duplicate): | |
| yield m | |
| def buffers(self, recurse: bool=True) -> Iterator[TensorLike]: | |
| for (name, buf) in self.named_buffers(recurse=recurse): | |
| yield buf | |
| def named_buffers(self, prefix: str='', recurse: bool=True, remove_duplicate: bool=True) -> Iterator[Tuple[str, TensorLike]]: | |
| gen = self._named_members(lambda module: module._buffers.items(), prefix=prefix, recurse=recurse, remove_duplicate=remove_duplicate) | |
| yield from gen | |
| T_destination = TypeVar('T_destination', bound=Dict[str, Any]) | |
| @overload | |
| def state_dict(self, *, destination: T_destination, prefix: str=..., keep_vars: bool=...) -> T_destination: | |
| ... | |
| @overload | |
| def state_dict(self, *, prefix: str=..., keep_vars: bool=...) -> Dict[str, Any]: | |
| ... | |
| def state_dict(self, *args, destination=None, prefix='', keep_vars=False): | |
| if len(args) > 0: | |
| if destination is None: | |
| destination = args[0] | |
| if len(args) > 1 and prefix == '': | |
| prefix = args[1] | |
| if len(args) > 2 and keep_vars is False: | |
| keep_vars = args[2] | |
| if destination is None: | |
| destination = OrderedDict() | |
| destination._metadata = OrderedDict() | |
| local_metadata = dict(version=self._version) | |
| if hasattr(destination, '_metadata'): | |
| destination._metadata[prefix[:-1]] = local_metadata | |
| self._save_to_state_dict(destination, prefix, keep_vars) | |
| for (name, module) in self._modules.items(): | |
| if module is not None: | |
| module.state_dict(destination=destination, prefix=prefix + name + '.', keep_vars=keep_vars) | |
| return destination | |
| def _save_to_state_dict(self, destination, prefix, keep_vars): | |
| for (name, buf) in self._buffers.items(): | |
| if buf is not None and name not in self._non_persistent_buffers_set: | |
| if isinstance(buf, Tensor): | |
| destination[prefix + name] = buf if keep_vars else buf.detach() | |
| else: | |
| destination[prefix + name] = buf | |
| def load_state_dict(self, state_dict: Mapping[str, Any], strict: bool=True, assign: bool=False): | |
| if not isinstance(state_dict, Mapping): | |
| raise TypeError(f'Expected state_dict to be dict-like, got {type(state_dict)}.') | |
| missing_keys: List[str] = [] | |
| unexpected_keys: List[str] = [] | |
| error_msgs: List[str] = [] | |
| metadata = getattr(state_dict, '_metadata', None) | |
| state_dict = OrderedDict(state_dict) | |
| if metadata is not None: | |
| state_dict._metadata = metadata | |
| def load(module, local_state_dict, prefix=''): | |
| local_metadata = {} if metadata is None else metadata.get(prefix[:-1], {}) | |
| if assign: | |
| local_metadata['assign_to_params_buffers'] = assign | |
| module._load_from_state_dict(local_state_dict, prefix, local_metadata, True, missing_keys, unexpected_keys, error_msgs) | |
| for (name, child) in module._modules.items(): | |
| if child is not None: | |
| child_prefix = prefix + name + '.' | |
| child_state_dict = {k: v for (k, v) in local_state_dict.items() if k.startswith(child_prefix)} | |
| load(child, child_state_dict, child_prefix) | |
| load(self, state_dict) | |
| del load | |
| if strict: | |
| if len(unexpected_keys) > 0: | |
| error_msgs.insert(0, 'Unexpected key(s) in state_dict: {}. '.format(', '.join((f'"{k}"' for k in unexpected_keys)))) | |
| if len(missing_keys) > 0: | |
| error_msgs.insert(0, 'Missing key(s) in state_dict: {}. '.format(', '.join((f'"{k}"' for k in missing_keys)))) | |
| if len(error_msgs) > 0: | |
| raise RuntimeError('Error(s) in loading state_dict for {}:\n\t{}'.format(self.__class__.__name__, '\n\t'.join(error_msgs))) | |
| return _IncompatibleKeys(missing_keys, unexpected_keys) | |
| def _load_from_state_dict(self, state_dict, prefix, local_metadata, strict, missing_keys, unexpected_keys, error_msgs): | |
| persistent_buffers = {k: v for (k, v) in self._buffers.items() if k not in self._non_persistent_buffers_set} | |
| local_name_params = persistent_buffers.items() | |
| local_state = {k: v for (k, v) in local_name_params if v is not None} | |
| for (name, param) in local_state.items(): | |
| key = prefix + name | |
| if key in state_dict: | |
| input_param = state_dict[key] | |
| if not isinstance(input_param, (Tensor, QTensor)): | |
| error_msgs.append(f'While copying the parameter named "{key}", expected Tensor-like object from checkpoint but received {type(input_param)}') | |
| continue | |
| if input_param.shape != param.shape: | |
| error_msgs.append('size mismatch for {}: copying a param with shape {} from checkpoint, the shape in current model is {}.'.format(key, input_param.shape, param.shape)) | |
| continue | |
| try: | |
| setattr(self, name, input_param) | |
| except Exception as ex: | |
| error_msgs.append(f'While copying the parameter named "{key}", whose dimensions in the model are {param.shape} and whose dimensions in the checkpoint are {input_param.shape}, an exception occurred : {ex.args}.') | |
| elif strict: | |
| missing_keys.append(key) | |
| if strict: | |
| for key in state_dict.keys(): | |
| if key.startswith(prefix): | |
| input_name = key[len(prefix):] | |
| input_name = input_name.split('.', 1)[0] | |
| if input_name not in self._modules and input_name not in local_state: | |
| unexpected_keys.append(key) | |
| def _named_members(self, get_members_fn, prefix='', recurse=True, remove_duplicate: bool=True): | |
| memo = set() | |
| modules = self.named_modules(prefix=prefix, remove_duplicate=remove_duplicate) if recurse else [(prefix, self)] | |
| for (module_prefix, module) in modules: | |
| members = get_members_fn(module) | |
| for (k, v) in members: | |
| if v is None or v in memo: | |
| continue | |
| if remove_duplicate: | |
| memo.add(v) | |
| name = module_prefix + ('.' if module_prefix else '') + k | |
| yield (name, v) | |
| def _get_name(self): | |
| return self.__class__.__name__ | |
| def _apply(self, fn): | |
| for module in self.children(): | |
| module._apply(fn) | |
| for (key, buf) in self._buffers.items(): | |
| if buf is not None: | |
| self._buffers[key] = fn(buf) | |
| return self | |
| def __move_tensor_to_device(self, tensor: TensorLike, device: str): | |
| if isinstance(tensor, Tensor): | |
| return tensor.to_device(device) | |
| else: | |
| raise NotImplementedError('Cannot offload QTensor to cuda, yet!') | |
| def device(self) -> str: | |
| tensor = next(self.buffers()) | |
| if isinstance(tensor, Tensor): | |
| return tensor.device | |
| else: | |
| return 'cpu' | |
| def cuda(self: T) -> T: | |
| def to_cuda(t: TensorLike): | |
| return self.__move_tensor_to_device(t, 'cuda') | |
| return self._apply(to_cuda) | |
| def cpu(self: T) -> T: | |
| def to_cpu(t: TensorLike): | |
| return self.__move_tensor_to_device(t, 'cpu') | |
| return self._apply(to_cpu) | |
| def __cast_tensor(self, tensor: TensorLike, dtype: Union[DType, str]): | |
| if isinstance(tensor, Tensor): | |
| return tensor.to_dtype(dtype) | |
| else: | |
| raise TypeError('candle.Module.to only accepts Tensor dtypes, but got desired dtype={}'.format(dtype)) | |
| def type(self: T, dst_type: Union[DType, str]) -> T: | |
| def cast(t: TensorLike): | |
| return self.__cast_tensor(t, dst_type) | |
| return self._apply(cast) | |
| @overload | |
| def to(self: T, device: str=..., dtype: Optional[Union[DType, str]]=...) -> T: | |
| ... | |
| @overload | |
| def to(self: T, dtype: Union[DType, str]) -> T: | |
| ... | |
| def to(self, *args, **kwargs): | |
| device = None | |
| dtype = None | |
| if args: | |
| for arg in args: | |
| if isinstance(arg, str): | |
| lower_arg = str(arg).lower() | |
| if lower_arg.startswith('cuda') or lower_arg == 'cpu': | |
| device = lower_arg | |
| else: | |
| dtype = arg | |
| elif isinstance(arg, DType): | |
| dtype = str(arg) | |
| else: | |
| raise TypeError('Module.to() received an invalid combination of arguments. Got: {}'.format(args)) | |
| if kwargs: | |
| device = kwargs.get('device', device) | |
| dtype = str(kwargs.get('dtype', dtype)) | |
| if device: | |
| device = device.lower() | |
| if dtype: | |
| dtype = dtype.lower() | |
| if dtype not in ['f32', 'f16', 'f64']: | |
| raise TypeError('candle.Module.to only accepts floating pointdtypes, but got desired dtype={}'.format(dtype)) | |
| def convert(t): | |
| if dtype: | |
| t = self.__cast_tensor(t, dtype) | |
| if device: | |
| t = self.__move_tensor_to_device(t, device) | |
| return t | |
| return self._apply(convert) | |
| def __setattr__(self, __name: str, __value: Any) -> None: | |
| if isinstance(__value, Module): | |
| self._modules[__name] = __value | |
| elif isinstance(__value, QTensor): | |
| if __name in self._quantizable_buffers: | |
| type = __value.ggml_dtype.lower() | |
| if type in ['f32', 'f16']: | |
| dequant = __value.dequantize() | |
| if type == 'f16': | |
| dequant = dequant.to_dtype('f16') | |
| self._buffers[__name] = dequant | |
| else: | |
| self._buffers[__name] = __value | |
| else: | |
| self._buffers[__name] = __value.dequantize() | |
| elif isinstance(__value, Tensor): | |
| self._buffers[__name] = __value | |
| else: | |
| super().__setattr__(__name, __value) | |
| def __getattr__(self, __name: str) -> Any: | |
| if '_modules' in self.__dict__: | |
| modules = self.__dict__['_modules'] | |
| if __name in modules: | |
| return modules[__name] | |
| if '_buffers' in self.__dict__: | |
| tensors = self.__dict__['_buffers'] | |
| if __name in tensors: | |
| return tensors[__name] | |
| return super().__getattribute__(__name) | |
| def __delattr__(self, name): | |
| if name in self._buffers: | |
| del self._buffers[name] | |
| elif name in self._modules: | |
| del self._modules[name] | |
| else: | |
| super().__delattr__(name) | |
| # File: candle-main/candle-pyo3/py_src/candle/nn/normalization.py | |
| import candle | |
| from candle import Tensor | |
| from .module import Module | |
| from typing import Union, List, Tuple, Optional, Any | |
| _shape_t = Union[int, List[int]] | |
| import numbers | |
| class LayerNorm(Module): | |
| __constants__ = ['normalized_shape', 'eps'] | |
| normalized_shape: Tuple[int, ...] | |
| eps: float | |
| def __init__(self, normalized_shape: _shape_t, eps: float=1e-05, bias: bool=True, device=None, dtype=None) -> None: | |
| factory_kwargs = {'device': device, 'dtype': dtype} | |
| super().__init__() | |
| if isinstance(normalized_shape, numbers.Integral): | |
| normalized_shape = (normalized_shape,) | |
| self.normalized_shape = tuple(normalized_shape) | |
| self.eps = eps | |
| self.weight = candle.ones(normalized_shape, **factory_kwargs) | |
| if bias: | |
| self.bias = candle.zeros(normalized_shape, **factory_kwargs) | |
| else: | |
| self.bias = None | |
| def forward(self, input: Tensor) -> Tensor: | |
| mean_x = input.sum_keepdim(2) / float(self.normalized_shape[-1]) | |
| x = input.broadcast_sub(mean_x) | |
| norm_x = x.sqr().sum_keepdim(2) / float(self.normalized_shape[-1]) | |
| x_normed = x.broadcast_div((norm_x + self.eps).sqrt()) | |
| x = x_normed.broadcast_mul(self.weight) | |
| if self.bias: | |
| x = x.broadcast_add(self.bias) | |
| return x | |
| def extra_repr(self) -> str: | |
| return '{normalized_shape}, eps={eps}, elementwise_affine={elementwise_affine}'.format(**self.__dict__) | |
| # File: candle-main/candle-pyo3/py_src/candle/nn/sparse.py | |
| from .module import Module | |
| from typing import Optional, Tuple, Any | |
| from candle import Tensor | |
| import candle | |
| class Embedding(Module): | |
| def __init__(self, num_embeddings: int, embedding_dim: int, device=None) -> None: | |
| factory_kwargs = {'device': device} | |
| super().__init__() | |
| self.num_embeddings = num_embeddings | |
| self.embedding_dim = embedding_dim | |
| self.weight = candle.randn((num_embeddings, embedding_dim), **factory_kwargs) | |
| def forward(self, indexes: Tensor) -> Tensor: | |
| final_dims = list(indexes.shape) | |
| final_dims.append(self.embedding_dim) | |
| indexes = indexes.flatten_all() | |
| values = self.weight.index_select(indexes, 0) | |
| return values.reshape(final_dims) | |
| # File: candle-main/candle-pyo3/py_src/candle/typing/__init__.py | |
| from typing import TypeVar, Union, Sequence | |
| _T = TypeVar('_T') | |
| _ArrayLike = Union[_T, Sequence[_T], Sequence[Sequence[_T]], Sequence[Sequence[Sequence[_T]]], Sequence[Sequence[Sequence[Sequence[_T]]]]] | |
| CPU: str = 'cpu' | |
| CUDA: str = 'cuda' | |
| Device = TypeVar('Device', CPU, CUDA) | |
| Scalar = Union[int, float] | |
| Index = Union[int, slice, None, 'Ellipsis'] | |
| Shape = Union[int, Sequence[int]] | |
| # File: candle-main/candle-pyo3/quant-llama.py | |
| import sys | |
| from typing import Dict, Tuple, Any | |
| import candle | |
| from candle.models.llama import QuantizedLlama | |
| from candle import utils | |
| MAX_SEQ_LEN = 4096 | |
| def gguf_rename(tensor_name: str): | |
| if tensor_name == 'token_embd.weight': | |
| return 'tok_embeddings.weight' | |
| if tensor_name == 'output_norm.weight': | |
| return 'norm.weight' | |
| tensor_name = tensor_name.replace('blk.', 'layers.') | |
| tensor_name = tensor_name.replace('.attn_q.', '.attention.wq.') | |
| tensor_name = tensor_name.replace('.attn_k.', '.attention.wk.') | |
| tensor_name = tensor_name.replace('.attn_v.', '.attention.wv.') | |
| tensor_name = tensor_name.replace('.attn_output.', '.attention.wo.') | |
| tensor_name = tensor_name.replace('.ffn_gate.', '.feed_forward.w1.') | |
| tensor_name = tensor_name.replace('.ffn_down.', '.feed_forward.w2.') | |
| tensor_name = tensor_name.replace('.ffn_up.', '.feed_forward.w3.') | |
| tensor_name = tensor_name.replace('.attn_norm.', '.attention_norm.') | |
| return tensor_name | |
| def main(): | |
| if len(sys.argv) < 2: | |
| raise ValueError('missing weight file argument') | |
| filename = sys.argv[1] | |
| print(f'reading model file {filename}') | |
| if filename.endswith('gguf'): | |
| (all_tensors, metadata) = utils.load_gguf(filename) | |
| vocab = metadata['tokenizer.ggml.tokens'] | |
| for (i, v) in enumerate(vocab): | |
| vocab[i] = '\n' if v == '<0x0A>' else v.replace('▁', ' ') | |
| hparams = {k: v for (k, v) in metadata.items() if not k.startswith('tokenizer')} | |
| print(hparams) | |
| hparams = {'n_vocab': len(vocab), 'n_embd': metadata['llama.embedding_length'], 'n_mult': 256, 'n_head': metadata['llama.attention.head_count'], 'n_head_kv': metadata['llama.attention.head_count_kv'], 'n_layer': metadata['llama.block_count'], 'n_rot': metadata['llama.rope.dimension_count'], 'rope_freq': metadata.get('llama.rope.freq_base', 10000.0), 'ftype': metadata['general.file_type'], 'context_length': metadata['llama.context_length']} | |
| all_tensors = {gguf_rename(k): v for (k, v) in all_tensors.items()} | |
| else: | |
| (all_tensors, hparams, vocab) = utils.load_ggml(filename) | |
| hparams['context_length'] = 2048 | |
| print(hparams) | |
| model = QuantizedLlama(hparams, all_tensors) | |
| print('model built, starting inference') | |
| tokens = [1] | |
| for token_idx in range(500): | |
| last_token = tokens[-1] | |
| lt = candle.tensor([last_token]).unsqueeze(0) | |
| logits = model.forward(lt, len(tokens)) | |
| m = logits.get(0).argmax_keepdim(-1) | |
| next_token = m.values()[0] | |
| print(vocab[next_token], end='', flush=True) | |
| tokens.append(next_token) | |
| if __name__ == '__main__': | |
| main() | |
| # File: candle-main/candle-pyo3/stub.py | |
| import argparse | |
| import inspect | |
| import os | |
| from typing import Optional | |
| import black | |
| from pathlib import Path | |
| import re | |
| INDENT = ' ' * 4 | |
| GENERATED_COMMENT = '# Generated content DO NOT EDIT\n' | |
| TYPING = 'from typing import Any, Callable, Dict, List, Optional, Tuple, Union, Sequence\nfrom os import PathLike\n' | |
| CANDLE_SPECIFIC_TYPING = 'from candle.typing import _ArrayLike, Device, Scalar, Index, Shape\n' | |
| CANDLE_TENSOR_IMPORTS = 'from candle import Tensor,DType,QTensor\n' | |
| RETURN_TYPE_MARKER = '&RETURNS&: ' | |
| ADDITIONAL_TYPEHINTS = {} | |
| FORWARD_REF_PATTERN = re.compile("ForwardRef\\('([^']+)'\\)") | |
| def do_indent(text: Optional[str], indent: str): | |
| if text is None: | |
| return '' | |
| return text.replace('\n', f'\n{indent}') | |
| def function(obj, indent: str, text_signature: str=None): | |
| if text_signature is None: | |
| text_signature = obj.__text_signature__ | |
| text_signature = text_signature.replace('$self', 'self').lstrip().rstrip() | |
| doc_string = obj.__doc__ | |
| if doc_string is None: | |
| doc_string = '' | |
| return_type = None | |
| doc_lines = doc_string.split('\n') | |
| if doc_lines[-1].lstrip().startswith(RETURN_TYPE_MARKER): | |
| return_type = doc_lines[-1].lstrip()[len(RETURN_TYPE_MARKER):].strip() | |
| doc_string = '\n'.join(doc_lines[:-1]) | |
| string = '' | |
| if return_type: | |
| string += f'{indent}def {obj.__name__}{text_signature} -> {return_type}:\n' | |
| else: | |
| string += f'{indent}def {obj.__name__}{text_signature}:\n' | |
| indent += INDENT | |
| string += f'{indent}"""\n' | |
| string += f'{indent}{do_indent(doc_string, indent)}\n' | |
| string += f'{indent}"""\n' | |
| string += f'{indent}pass\n' | |
| string += '\n' | |
| string += '\n' | |
| return string | |
| def member_sort(member): | |
| if inspect.isclass(member): | |
| value = 10 + len(inspect.getmro(member)) | |
| else: | |
| value = 1 | |
| return value | |
| def fn_predicate(obj): | |
| value = inspect.ismethoddescriptor(obj) or inspect.isbuiltin(obj) | |
| if value: | |
| return obj.__text_signature__ and (not obj.__name__.startswith('_')) | |
| if inspect.isgetsetdescriptor(obj): | |
| return not obj.__name__.startswith('_') | |
| return False | |
| def get_module_members(module): | |
| members = [member for (name, member) in inspect.getmembers(module) if not name.startswith('_') and (not inspect.ismodule(member))] | |
| members.sort(key=member_sort) | |
| return members | |
| def pyi_file(obj, indent=''): | |
| string = '' | |
| if inspect.ismodule(obj): | |
| string += GENERATED_COMMENT | |
| string += TYPING | |
| string += CANDLE_SPECIFIC_TYPING | |
| if obj.__name__ != 'candle.candle': | |
| string += CANDLE_TENSOR_IMPORTS | |
| members = get_module_members(obj) | |
| for member in members: | |
| string += pyi_file(member, indent) | |
| elif inspect.isclass(obj): | |
| indent += INDENT | |
| mro = inspect.getmro(obj) | |
| if len(mro) > 2: | |
| inherit = f'({mro[1].__name__})' | |
| else: | |
| inherit = '' | |
| string += f'class {obj.__name__}{inherit}:\n' | |
| body = '' | |
| if obj.__doc__: | |
| body += f'{indent}"""\n{indent}{do_indent(obj.__doc__, indent)}\n{indent}"""\n' | |
| fns = inspect.getmembers(obj, fn_predicate) | |
| if obj.__text_signature__: | |
| body += f'{indent}def __init__{obj.__text_signature__}:\n' | |
| body += f'{indent + INDENT}pass\n' | |
| body += '\n' | |
| if obj.__name__ in ADDITIONAL_TYPEHINTS: | |
| additional_members = inspect.getmembers(ADDITIONAL_TYPEHINTS[obj.__name__]) | |
| additional_functions = [] | |
| for (name, member) in additional_members: | |
| if inspect.isfunction(member): | |
| additional_functions.append((name, member)) | |
| def process_additional_function(fn): | |
| signature = inspect.signature(fn) | |
| cleaned_signature = re.sub(FORWARD_REF_PATTERN, '\\1', str(signature)) | |
| string = f'{indent}def {fn.__name__}{cleaned_signature}:\n' | |
| string += f'{indent + INDENT}"""{indent + INDENT}{do_indent(fn.__doc__, indent + INDENT)}{indent + INDENT}"""\n' | |
| string += f'{indent + INDENT}pass\n' | |
| string += '\n' | |
| return string | |
| for (name, fn) in additional_functions: | |
| body += process_additional_function(fn) | |
| for (name, fn) in fns: | |
| body += pyi_file(fn, indent=indent) | |
| if not body: | |
| body += f'{indent}pass\n' | |
| string += body | |
| string += '\n\n' | |
| elif inspect.isbuiltin(obj): | |
| string += f'{indent}@staticmethod\n' | |
| string += function(obj, indent) | |
| elif inspect.ismethoddescriptor(obj): | |
| string += function(obj, indent) | |
| elif inspect.isgetsetdescriptor(obj): | |
| string += f'{indent}@property\n' | |
| string += function(obj, indent, text_signature='(self)') | |
| elif obj.__class__.__name__ == 'DType': | |
| string += f'class {str(obj).lower()}(DType):\n' | |
| string += f'{indent + INDENT}pass\n' | |
| else: | |
| raise Exception(f'Object {obj} is not supported') | |
| return string | |
| def py_file(module, origin): | |
| members = get_module_members(module) | |
| string = GENERATED_COMMENT | |
| string += f'from .. import {origin}\n' | |
| string += '\n' | |
| for member in members: | |
| if hasattr(member, '__name__'): | |
| name = member.__name__ | |
| else: | |
| name = str(member) | |
| string += f'{name} = {origin}.{name}\n' | |
| return string | |
| def do_black(content, is_pyi): | |
| mode = black.Mode(target_versions={black.TargetVersion.PY35}, line_length=119, is_pyi=is_pyi, string_normalization=True) | |
| try: | |
| return black.format_file_contents(content, fast=True, mode=mode) | |
| except black.NothingChanged: | |
| return content | |
| def write(module, directory, origin, check=False): | |
| submodules = [(name, member) for (name, member) in inspect.getmembers(module) if inspect.ismodule(member)] | |
| filename = os.path.join(directory, '__init__.pyi') | |
| pyi_content = pyi_file(module) | |
| pyi_content = do_black(pyi_content, is_pyi=True) | |
| os.makedirs(directory, exist_ok=True) | |
| if check: | |
| with open(filename, 'r') as f: | |
| data = f.read() | |
| print('generated content') | |
| print(pyi_content) | |
| assert data == pyi_content, f'The content of {filename} seems outdated, please run `python stub.py`' | |
| else: | |
| with open(filename, 'w') as f: | |
| f.write(pyi_content) | |
| filename = os.path.join(directory, '__init__.py') | |
| py_content = py_file(module, origin) | |
| py_content = do_black(py_content, is_pyi=False) | |
| os.makedirs(directory, exist_ok=True) | |
| is_auto = False | |
| if not os.path.exists(filename): | |
| is_auto = True | |
| else: | |
| with open(filename, 'r') as f: | |
| line = f.readline() | |
| if line == GENERATED_COMMENT: | |
| is_auto = True | |
| if is_auto: | |
| if check: | |
| with open(filename, 'r') as f: | |
| data = f.read() | |
| print('generated content') | |
| print(py_content) | |
| assert data == py_content, f'The content of {filename} seems outdated, please run `python stub.py`' | |
| else: | |
| with open(filename, 'w') as f: | |
| f.write(py_content) | |
| for (name, submodule) in submodules: | |
| write(submodule, os.path.join(directory, name), f'{name}', check=check) | |
| def extract_additional_types(module): | |
| additional_types = {} | |
| for (name, member) in inspect.getmembers(module): | |
| if inspect.isclass(member): | |
| if hasattr(member, '__name__'): | |
| name = member.__name__ | |
| else: | |
| name = str(member) | |
| if name not in additional_types: | |
| additional_types[name] = member | |
| return additional_types | |
| if __name__ == '__main__': | |
| parser = argparse.ArgumentParser() | |
| parser.add_argument('--check', action='store_true') | |
| args = parser.parse_args() | |
| cwd = Path.cwd() | |
| directory = 'py_src/candle/' | |
| if cwd.name != 'candle-pyo3': | |
| directory = f'candle-pyo3/{directory}' | |
| import candle | |
| import _additional_typing | |
| ADDITIONAL_TYPEHINTS = extract_additional_types(_additional_typing) | |
| write(candle.candle, directory, 'candle', check=args.check) | |