# 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 '' 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)