Datasets:

---

tianyang

/

repobench_python_v1.1

like 7

[ { "identifier": "config", "path": "kusa_base.py", "snippet": "async def isUserExist(qqNum) -> bool:\nasync def isSuperAdmin(qqNum) -> bool:\nasync def buying(qqNum, itemNameBuying, itemAmountBuying, totalPrice, isUsingAdvKusa=False) -> bool:\nasync def selling(qqNum, itemNameSelling, itemAmountSelling, totalPrice, isUsingAdvKusa=False) -> bool:\nasync def sendLog(message):" }, { "identifier": "nameDetailSplit", "path": "utils.py", "snippet": "def nameDetailSplit(strippedText):\n if not strippedText:\n return \"\", \"\"\n colonEnIndex = strippedText.find(\":\")\n colonCnIndex = strippedText.find(\"：\")\n colonEnIndex = len(strippedText) if colonEnIndex == -1 else colonEnIndex\n colonCnIndex = len(strippedText) if colonCnIndex == -1 else colonCnIndex\n # 英文冒号\n if colonEnIndex < colonCnIndex:\n return strippedText.split(':', 1)\n # 中文冒号\n if colonCnIndex < colonEnIndex:\n return strippedText.split('：', 1)\n # 没有冒号\n return strippedText, \"\"" }, { "identifier": "CQ_injection_check_command", "path": "decorator.py", "snippet": "def CQ_injection_check_command(func):\n @wraps(func)\n def check(session: CommandSession):\n if 'CQ:' in session.current_arg:\n return holder(session)\n return func(session)\n\n return check" } ]

[ { "identifier": "W4A8BF32OF32Linear", "path": "dgq/models/linear.py", "snippet": "class W4A8BF32OF32Linear(torch.nn.Module):\n # For qkv_proj\n def __init__(self, in_features, out_features, groupsize=128):\n super().__init__()\n self.in_features = in_features\n self.out_features = out_features\n self.groupsize = groupsize\n self.register_buffer('weight', torch.zeros((self.out_features,\n self.in_features // 2), dtype=torch.int8, requires_grad=False))\n self.register_buffer('bias', torch.zeros(\n (1, self.out_features), dtype=torch.float, requires_grad=False))\n self.register_buffer('a', torch.zeros(1, self.out_features))\n self.register_buffer('b', torch.zeros(1, self.out_features))\n self.register_buffer('scales8', torch.zeros((self.out_features, self.in_features//self.groupsize),dtype=torch.int8))\n self.register_buffer('zeros', torch.zeros((self.out_features, self.in_features//self.groupsize),dtype=torch.int8))\n\n def to(self, *args, **kwargs):\n super().to(*args, **kwargs)\n self.weight = self.weight.to(*args, **kwargs)\n self.bias = self.bias.to(*args, **kwargs)\n return self\n\n @torch.no_grad()\n def forward(self, x):\n x_shape = x.shape\n x = x.view(-1, x_shape[-1])\n y = linear_a8_w4_bfp32_ofp32(x, self.weight, self.bias,\n self.a, self.b,\n self.scales8, self.zeros, self.in_features, self.out_features,\n self.groupsize // 8)\n y = y.view(*x_shape[:-1], -1)\n return y\n\n @staticmethod\n def from_float(module: QuantLinear, input_scale):\n a8w4_module = W4A8BF32OF32Linear(\n module.in_features, module.out_features, module.groupsize)\n alpha = module.wscales8.float() * input_scale\n a8w4_module.weight = module.qweight\n if module.bias is not None:\n a8w4_module.bias = module.bias.float()\n a8w4_module.a = alpha\n a8w4_module.scales8 = module.wscales\n a8w4_module.zeros = module.wzeros\n return a8w4_module" }, { "identifier": "W4A8B8O8Linear", "path": "dgq/models/linear.py", "snippet": "class W4A8B8O8Linear(torch.nn.Module):\n # For qkv_proj\n def __init__(self, in_features, out_features, groupsize=128):\n super().__init__()\n self.in_features = in_features\n self.out_features = out_features \n self.groupsize = groupsize\n self.register_buffer('weight', torch.zeros((self.out_features,\n self.in_features // 2), dtype=torch.int8, requires_grad=False))\n self.register_buffer('bias', torch.zeros(\n (1, self.out_features), dtype=torch.int8, requires_grad=False))\n self.register_buffer('a', torch.zeros(1, self.out_features))\n self.register_buffer('b', torch.ones(1))\n self.register_buffer('scales8', torch.zeros((self.out_features, self.in_features//self.groupsize),dtype=torch.int8))\n self.register_buffer('zeros', torch.zeros((self.out_features, self.in_features//self.groupsize),dtype=torch.int8))\n def to(self, *args, **kwargs):\n super().to(*args, **kwargs)\n self.weight = self.weight.to(*args, **kwargs)\n self.bias = self.bias.to(*args, **kwargs)\n return self\n\n @torch.no_grad()\n def forward(self, x):\n x_shape = x.shape\n x = x.view(-1, x_shape[-1])\n y = linear_a8_w4_b8_o8(x, self.weight, self.bias,\n self.a, self.b,\n self.scales8, self.zeros, self.in_features, self.out_features,\n self.groupsize // 8)\n y = y.view(*x_shape[:-1], -1)\n return y\n\n @staticmethod\n def from_float(module: QuantLinear, input_scale, output_scale):\n a8w4_module = W4A8B8O8Linear(\n module.in_features, module.out_features)\n int8_bias, bias_scale = quantize_per_tensor_absmax(module.bias)\n alpha = input_scale * module.wscales8.float() / output_scale\n beta = bias_scale / output_scale\n a8w4_module.weight = module.qweight\n a8w4_module.bias = int8_bias\n a8w4_module.a = alpha.reshape(-1, 8, 2, 8).transpose(1, 2).flatten()\n a8w4_module.b = beta\n a8w4_module.scales8 = module.wscales\n a8w4_module.zeros = module.wzeros\n return a8w4_module" }, { "identifier": "LayerNormQ", "path": "dgq/models/fused.py", "snippet": "class LayerNormQ(torch.nn.Module):\n def __init__(self, dim, eps=1e-5):\n super().__init__()\n self.input_scale = 1.0\n self.eps = eps\n self.register_buffer('weight', torch.ones(dim, dtype=torch.float32))\n self.register_buffer('bias', torch.zeros(dim, dtype=torch.float32))\n\n def forward(self, x):\n x = x.to(self.weight.dtype)\n ln_output_fp = torch.nn.functional.layer_norm(\n x, x.shape[-1:], self.weight, self.bias, self.eps)\n ln_output_int8 = ln_output_fp.round().clamp(-128, 127).to(torch.int8)\n return ln_output_int8\n\n @staticmethod\n def from_float(module: torch.nn.LayerNorm, output_scale: float):\n assert module.normalized_shape[0] == module.weight.numel()\n assert module.normalized_shape[0] == module.bias.numel()\n q_module = LayerNormQ(module.normalized_shape[0], module.eps)\n q_module.weight = module.weight.float() / output_scale\n q_module.bias = module.bias.float() / output_scale\n return q_module" }, { "identifier": "BMM_S8T_S8N_F32T", "path": "dgq/models/bmm.py", "snippet": "class BMM_S8T_S8N_F32T(torch.nn.Module):\n def __init__(self, alpha):\n super().__init__()\n self.register_buffer('a', torch.tensor(alpha))\n\n @torch.no_grad()\n def forward(self, a, b):\n # a: [B, M, K] int8\n # b: [B, N, K] int8\n # return: [B, M, N] int32\n return bmm_s8t_s8n_f32t(a, b, self.a.item())\n\n @staticmethod\n def from_scale(a_scale, b_scale):\n bmm_module = BMM_S8T_S8N_F32T(1.0)\n alpha = a_scale * b_scale\n if not torch.is_tensor(alpha):\n alpha = torch.tensor(alpha)\n bmm_module.a = alpha\n return bmm_module" } ]

[ { "identifier": "CUSTOM_ALGO_ID", "path": "news.py", "snippet": "CUSTOM_ALGO_ID = st.secrets[\"custom_algo_id\"]" }, { "identifier": "initialize_session", "path": "news.py", "snippet": "def initialize_session(user_input=\"\"):\n \"\"\"Initialize or restart the session.\"\"\"\n if user_input:\n st.session_state.username = user_input\n username_suffix = st.session_state.username if \"username\" in st.session_state else None\n if username_suffix:\n st.session_state.session = st.session_state.personalized.session(\n AlgorithmLabel.CUSTOM,\n custom_id=CUSTOM_ALGO_ID,\n vdbid=FIRSTBATCH_DB_NAME,\n session_id=\"rss_feed\" + username_suffix\n )\n else:\n st.session_state.session = st.session_state.personalized.session(\n AlgorithmLabel.CUSTOM,\n custom_id=CUSTOM_ALGO_ID,\n vdbid=FIRSTBATCH_DB_NAME\n )\n st.session_state.batches = []\n st.session_state.ids = []\n st.session_state.likes = []\n st.session_state.html_content = \"\"\"\n <div class=\"chat-container\">\n <div class=\"chat-box\">\n <div class=\"chat-output\" id=\"chat-output\"></div>\n </div>\n </div>\n \"\"\"\n st.session_state.chat_placeholder = st.empty()\n st.session_state.chat_history = \"\"\n st.session_state.chat_loader = 0" }, { "identifier": "fetch_content", "path": "news.py", "snippet": "def fetch_content():\n \"\"\"Fetch content for the current session.\"\"\"\n ids, batch = st.session_state.personalized.batch(st.session_state.session)\n st.session_state.batches += batch\n st.session_state.ids += ids" }, { "identifier": "chat", "path": "chat_tools/kernel.py", "snippet": "def chat(model, prompt, message):\n if \"chat_history\" not in st.session_state:\n st.session_state[\"chat_history\"] = \"\"\n context, user_interaction = generate_session_context(st.session_state)\n runnable = prompt | model | StrOutputParser()\n soup = BeautifulSoup(st.session_state.html_content, 'html.parser')\n chat_output = soup.find(id='chat-output')\n if \"init\" in st.session_state:\n user_div = soup.new_tag(\"div\", **{'class': 'user-message'})\n user_div.string = f\"{st.session_state.username}: {message}\"\n chat_output.append(user_div)\n stream_handler = StreamHandler(soup=soup, chat_output=chat_output)\n strategy = no_history if st.session_state[\"chat_history\"] == \"\" else has_history\n answer = runnable.invoke(\n ({\"context\": context,\n \"user_interaction\": user_interaction,\n \"user_input\": message,\n \"chat_history\": st.session_state[\"chat_history\"],\n \"strategy\": strategy}),\n config={\"callbacks\": [stream_handler]})\n st.session_state[\"chat_history\"] += f\"\\nUser:> {message}\\nChatBot:> {answer}\\n\"" }, { "identifier": "setup_chat_with_memory", "path": "chat_tools/kernel.py", "snippet": "def setup_chat_with_memory():\n sk_prompt = \"\"\" \nAvoid using \"Answer:\" or \"Chatbot>\" as a response header. Responses should be concise, not exceeding 250 tokens.\n\nUser preferences is user's interaction with the articles. Use the articles that the user has liked for tailored recommendations.\nRelevant Articles for Context and Suggestions is the articles which exctracted user has liked. Use the articles that the more exploration and alternative.\nPrior Conversation Record is the previous chat history. This one is least important for user interests. Use that for engagement and continuity.\nUpcoming Chatbot Response will focus on is the strategy for the upcoming response. Use that for learn about user state on product experience.\n\nUser Preferences:\n{user_interaction}\n\nRelevant Articles for Context and Suggestions:\n{context}\n\nPrior Conversation Record:\n{chat_history}\n\nUser Inquiry:\n{user_input}\n\nUpcoming Chatbot Response will focus on:\n{strategy}\n\"\"\".strip()\n\n prompt = PromptTemplate(\n template=sk_prompt, input_variables=[\"context\", \"user_input\", \"chat_history\", \"user_interaction\", \"strategy\"]\n )\n chain = ChatOpenAI(model_name=\"gpt-4-1106-preview\", temperature=0.8, streaming=True, max_tokens=512)\n\n return chain, prompt" }, { "identifier": "css_", "path": "markdowns/markdowns_chat.py", "snippet": "" } ]

[ { "identifier": "Config", "path": "monzo_utils/lib/config.py", "snippet": "class Config(metaclass=Singleton):\n\n def __init__(self, config=None, config_path=None):\n if config_path is None:\n homedir = pwd.getpwuid(os.getuid()).pw_dir\n config_path = f\"{homedir}/.monzo\"\n\n if not os.path.exists(config_path):\n os.mkdir(config_path, 0o755)\n\n self.config_file = f\"{config_path}/config.yaml\"\n\n if config:\n self.config = config\n else:\n if not os.path.exists(self.config_file):\n sys.stderr.write(f\"config file not found: {self.config_file}, run setup first.\\n\")\n sys.exit(1)\n\n self.config = yaml.safe_load(open(self.config_file).read())\n\n\n def __getattr__(self, name):\n if name in self.config:\n return self.config[name]\n\n return object.__getattribute__(self, name)\n\n\n def set(self, key, value):\n self.config[key] = value\n\n\n @property\n def keys(self):\n return self.config.keys()\n\n\n def save(self):\n with open(self.config_file, 'w') as f:\n f.write(yaml.dump(self.config))" }, { "identifier": "Transaction", "path": "monzo_utils/model/transaction.py", "snippet": "class Transaction(BaseModel):\n\n DISPLAY_KEYS = ['date','type','money_in','money_out','pending','description']\n RELATIONSHIPS = {\n 'account': ['`transaction`.account_id', 'account.id'],\n 'transaction_metadata': ['`transaction`.id', 'transaction_metadata.transaction_id'],\n 'pot': ['`transaction`.pot_id', 'pot.id']\n }" }, { "identifier": "Transactions", "path": "monzo_utils/lib/transactions.py", "snippet": "class Transactions(metaclass=Singleton):\n seen = {}" } ]

[ { "identifier": "ConditionalAutoencoder", "path": "src/conditional/conditional_autoencoder.py", "snippet": "class ConditionalAutoencoder(nn.Module):\n def __init__(\n self,\n emb_channels: int,\n z_channels: int,\n channels: int,\n channel_multipliers: List[int],\n n_resnet_blocks: int,\n in_channels: int,\n out_channels: int,\n ) -> None:\n super().__init__()\n self.encoder = Encoder(\n channels=channels,\n channel_multipliers=channel_multipliers,\n n_resnet_blocks=n_resnet_blocks,\n in_channels=in_channels,\n z_channels=z_channels,\n )\n self.cond_decoder = ConditionalDecoder(\n channels=channels,\n channel_multipliers=channel_multipliers,\n n_resnet_blocks=n_resnet_blocks,\n out_channels=out_channels,\n z_channels=z_channels,\n )\n self.cond_encoder = ConditionalEncoder(\n channels=channels,\n channel_multipliers=channel_multipliers,\n n_resnet_blocks=n_resnet_blocks,\n in_channels=in_channels,\n )\n self.quant_conv = nn.Conv2d(2 * z_channels, 2 * emb_channels, 1)\n self.post_quant_conv = nn.Conv2d(emb_channels, z_channels, 1)\n\n def encode(self, img: torch.Tensor) -> GaussianDistribution:\n z = self.encoder(img)\n moments = self.quant_conv(z)\n return GaussianDistribution(moments)\n\n def encode_cond(self, cond: torch.Tensor) -> List[torch.Tensor]:\n conds_z = self.cond_encoder(cond)\n return conds_z\n\n def decode(self, z: torch.Tensor, conds_z: List[torch.Tensor]) -> torch.Tensor:\n z = self.post_quant_conv(z)\n return self.cond_decoder(z, conds_z)\n\n @classmethod\n def load_from_saved(cls, pretrained_ckpt, pretrained_yaml, checkpoint_ckpt):\n pretrained_ckpt = torch.load(pretrained_ckpt)\n pretrained_yaml = OmegaConf.load(pretrained_yaml)\n checkpoint_ckpt = torch.load(checkpoint_ckpt)\n\n cond_autoencoder = cls(\n emb_channels=pretrained_yaml.params.embed_dim,\n z_channels=pretrained_yaml.params.ddconfig.z_channels,\n channels=pretrained_yaml.params.ddconfig.ch,\n channel_multipliers=pretrained_yaml.params.ddconfig.ch_mult,\n n_resnet_blocks=pretrained_yaml.params.ddconfig.num_res_blocks,\n in_channels=pretrained_yaml.params.ddconfig.in_channels,\n out_channels=pretrained_yaml.params.ddconfig.out_ch,\n )\n\n quant_conv_state_dict = {}\n post_quant_conv_state_dict = {}\n encoder_state_dict = {}\n cond_encoder_state_dict = {}\n cond_decoder_state_dict = {}\n\n for k, v in pretrained_ckpt[\"state_dict\"].items():\n if k.startswith(\"quant_conv\"):\n quant_conv_state_dict[k.replace(\"quant_conv.\", \"\", 1)] = v\n elif k.startswith(\"post_quant_conv\"):\n post_quant_conv_state_dict[k.replace(\"post_quant_conv.\", \"\", 1)] = v\n elif k.startswith(\"encoder\"):\n encoder_state_dict[k.replace(\"encoder.\", \"\", 1)] = v\n elif k.startswith(\"decoder\") or k.startswith(\"loss\"):\n continue\n else:\n raise KeyError(f\"Unexpected state_dict key: {k}\")\n\n cond_encoder_state_dict = checkpoint_ckpt[\"cond_encoder_state_dict\"]\n cond_decoder_state_dict = checkpoint_ckpt[\"cond_decoder_state_dict\"]\n\n cond_autoencoder.quant_conv.load_state_dict(quant_conv_state_dict, strict=True)\n cond_autoencoder.post_quant_conv.load_state_dict(\n post_quant_conv_state_dict, strict=True\n )\n cond_autoencoder.encoder.load_state_dict(encoder_state_dict, strict=True)\n cond_autoencoder.cond_encoder.load_state_dict(\n cond_encoder_state_dict, strict=True\n )\n cond_autoencoder.cond_decoder.load_state_dict(\n cond_decoder_state_dict, strict=True\n )\n\n return cond_autoencoder" }, { "identifier": "ConditionalTestDataset", "path": "src/conditional/conditional_test_dataset.py", "snippet": "class ConditionalTestDataset(Dataset):\n def __init__(self, dataset_path, transform=None):\n self.dataset_path = dataset_path\n self.transform = transform\n self.cond_dataset = []\n\n grayscale = get_entries(f\"{dataset_path}/grayscale/*.png\")\n style2paints = get_entries(f\"{dataset_path}/style2paints/*.png\")\n\n assert len(grayscale) == len(style2paints)\n\n for g, s in zip(grayscale, style2paints):\n self.cond_dataset.append({\"grayscale\": g, \"style2paints\": s})\n\n def __len__(self):\n return len(self.cond_dataset)\n\n def __getitem__(self, idx):\n g = Image.open(self.cond_dataset[idx][\"grayscale\"]).convert(\"RGB\")\n s = Image.open(self.cond_dataset[idx][\"style2paints\"]).convert(\"RGB\")\n\n if self.transform is not None:\n return self.transform(g, s)\n\n return g, s" }, { "identifier": "resize_max", "path": "src/utils.py", "snippet": "def resize_max(img, max_size):\n w, h = img.size\n if w > max_size or h > max_size:\n if w <= h:\n h = int(float(h) * float(max_size) / float(w))\n w = max_size\n else:\n w = int(float(w) * float(max_size) / float(h))\n h = max_size\n img = img.resize((w, h), Image.Resampling.LANCZOS)\n\n return img" } ]

[ { "identifier": "RangeGroupData", "path": "bkflow_feel/data_models.py", "snippet": "class RangeGroupData(BaseModel):\n left_val: Any\n right_val: Any\n left_operator: RangeGroupOperator\n right_operator: RangeGroupOperator" }, { "identifier": "RangeGroupOperator", "path": "bkflow_feel/data_models.py", "snippet": "class RangeGroupOperator(enum.Enum):\n GT = \"greater than\"\n GTE = \"greater than or equal\"\n LT = \"less than\"\n LTE = \"less than or equal\"" }, { "identifier": "FEELFunctionsManager", "path": "bkflow_feel/utils.py", "snippet": "class FEELFunctionsManager:\n __hub = {}\n\n @classmethod\n def register_invocation_cls(cls, invocation_cls):\n func_name = invocation_cls.Meta.func_name\n existed_invocation_cls = cls.__hub.get(func_name)\n if existed_invocation_cls:\n raise RuntimeError(\n \"func register error, {}'s func_name {} conflict with {}\".format(\n existed_invocation_cls, func_name, invocation_cls\n )\n )\n\n cls.__hub[func_name] = invocation_cls\n\n @classmethod\n def register_funcs(cls, func_dict):\n for func_name, func_path in func_dict.items():\n if not isinstance(func_name, str):\n raise ValueError(f\"func_name {func_name} should be string\")\n if func_name in cls.__hub:\n raise ValueError(\n \"func register error, {}'s func_name {} conflict with {}\".format(\n func_path, func_name, cls.__hub[func_name]\n )\n )\n cls.__hub[func_name] = func_path\n\n @classmethod\n def clear(cls):\n cls.__hub = {}\n\n @classmethod\n def all_funcs(cls):\n funcs = {}\n for version, invocation_cls in cls.__hub.items():\n funcs[version] = invocation_cls\n return funcs\n\n @classmethod\n def get_func(cls, func_name) -> Callable:\n func_obj = cls.__hub.get(func_name)\n if not func_obj:\n raise ValueError(\"func object {} not found\".format(func_name))\n\n if isinstance(func_obj, FEELInvocationMeta):\n return func_obj()\n else:\n module_path, func_name = str(func_obj).rsplit(\".\", 1)\n module = importlib.import_module(module_path)\n func = getattr(module, func_name)\n return func\n\n @classmethod\n def func_call(cls, func_name, *args, **kwargs):\n func = cls.get_func(func_name)\n return func(*args, **kwargs)" }, { "identifier": "BinaryOperationValidator", "path": "bkflow_feel/validators.py", "snippet": "class BinaryOperationValidator(Validator):\n def validate(self, left_item, right_item, instance_type=None, *args, **kwargs) -> ValidationResult:\n if not isinstance(left_item, type(right_item)):\n return ValidationResult(\n False, f\"Type of both operators must be same, get {type(left_item)} and {type(right_item)}\",\n )\n if instance_type is not None and not isinstance(left_item, instance_type):\n return ValidationResult(\n False, f\"Type of both operators must be {instance_type}, get {type(left_item)} and {type(right_item)}\",\n )\n return ValidationResult(True)" }, { "identifier": "DummyValidator", "path": "bkflow_feel/validators.py", "snippet": "class DummyValidator(Validator):\n def validate(self, *args, **kwargs):\n pass" }, { "identifier": "ListsLengthValidator", "path": "bkflow_feel/validators.py", "snippet": "class ListsLengthValidator(Validator):\n def validate(self, lists, *args, **kwargs):\n if not lists or all(len(alist) == len(lists[0]) for alist in lists):\n return ValidationResult(True)\n return ValidationResult(False, \"lists length not equal\")" } ]

[ { "identifier": "Resource", "path": "oxijen/rdf_model.py", "snippet": "class Resource(ABC):\n\n @property\n def node(self):\n return self._node\n\n @property\n def graph(self):\n return self._graph\n\n @property\n def is_anon(self):\n if isinstance(self.node, NamedNode):\n return False\n else:\n return True\n \n @property\n def uri(self):\n if isinstance(self.node, NamedNode):\n return self.node.value\n else:\n return None\n\n @property\n def id(self):\n if isinstance(self.node, BlankNode):\n return self.node.value\n else:\n return None\n \n @abstractmethod\n def add_property(self, property: 'Property', value: Union['Resource', Literal]) -> 'Resource':\n pass\n\n @abstractmethod\n def remove_all(self, property: 'Property') -> 'Resource':\n pass\n\n @abstractmethod\n def list_properties(self, property: 'Property') -> Iterator[Triple]:\n pass" }, { "identifier": "Property", "path": "oxijen/rdf_model.py", "snippet": "class Property(Resource):\n\n pass" }, { "identifier": "Graph", "path": "oxijen/rdf_model.py", "snippet": "class Graph(ABC):\n\n @abstractmethod\n def __len__(self) -> int:\n pass\n\n @abstractmethod\n def create_resource(self, uri: Optional[str] = None) -> Resource:\n pass\n\n @abstractmethod\n def create_property(self, uri: str) -> Property:\n pass\n\n @abstractmethod\n def create_literal(self, value: str, language: Optional[str] = None) -> Literal:\n pass\n\n @abstractmethod\n def create_typed_literal(self, value: Any, datatype: Optional[Union[str, NamedNode]] = None) -> Literal:\n pass\n\n @abstractmethod\n def list_subjects(self) -> Iterator[Resource]:\n pass\n\n @abstractmethod\n def list_triples(self) -> Iterator[Triple]:\n pass\n\n @abstractmethod\n def add(self, triples: Union[Iterator[Triple], 'Graph']) -> 'Graph':\n pass\n\n @abstractmethod\n def remove_all(self ) -> 'Graph':\n pass" }, { "identifier": "Dataset", "path": "oxijen/rdf_model.py", "snippet": "class Dataset(ABC):\n\n @property\n def default_graph(self):\n pass\n \n @abstractmethod\n def graph_names(self) -> Iterator[Resource]:\n pass\n\n @abstractmethod\n def contains_named_graph(self, name: Union[str, Resource]) -> bool:\n pass\n\n @abstractmethod\n def get_named_graph(self, name: Union[str, Resource]) -> Graph:\n pass\n\n @abstractmethod\n def add_named_graph(self, name: Union[str, Resource], graph: Graph) -> 'Dataset':\n pass\n\n @abstractmethod\n def remove_named_graph(self, name: Union[str, Resource], graph: Graph) -> 'Dataset':\n pass\n\n @abstractmethod\n def list_quads(self) -> Iterator[Quad]:\n pass" }, { "identifier": "XSD", "path": "oxijen/model_impl/xsd.py", "snippet": "class XSD(Enum):\n\n NS : str = \"http://www.w3.org/2001/XMLSchema#\"\n\n INTEGER = NS + \"integer\"\n STRING = NS + \"string\"\n FLOAT = NS + \"float\"" } ]

[ { "identifier": "LyzrLLMFactory", "path": "lyzr/base/llm.py", "snippet": "class LyzrLLMFactory:\n\n def __init__(self) -> None:\n None\n @staticmethod\n def from_defaults(model: str = \"gpt-3.5-turbo\", **kwargs) -> LLM:\n return LiteLLM(model=model, **kwargs)" }, { "identifier": "LyzrService", "path": "lyzr/base/service.py", "snippet": "class LyzrService:\n @staticmethod\n def from_defaults(\n llm: Optional[LLMType] = \"default\",\n embed_model: Optional[EmbedType] = \"default\",\n system_prompt: str = None,\n query_wrapper_prompt: Union[str, BasePromptTemplate] = None,\n **kwargs,\n ) -> ServiceContext: \n if isinstance(query_wrapper_prompt, str):\n query_wrapper_prompt = PromptTemplate(template=query_wrapper_prompt)\n\n callback_manager: CallbackManager = kwargs.get(\n \"callback_manager\", CallbackManager()\n )\n\n node_parser = SimpleNodeParser.from_defaults(\n chunk_size=750,\n chunk_overlap=100,\n callback_manager=callback_manager,\n )\n\n service_context = ServiceContext.from_defaults(\n llm=llm,\n embed_model=embed_model,\n system_prompt=system_prompt,\n query_wrapper_prompt=query_wrapper_prompt,\n callback_manager=callback_manager,\n node_parser=node_parser,\n **kwargs,\n )\n\n return service_context" }, { "identifier": "LyzrVectorStoreIndex", "path": "lyzr/base/vector_store.py", "snippet": "class LyzrVectorStoreIndex:\n @staticmethod\n def from_defaults(\n vector_store_type: str = \"LanceDBVectorStore\", \n documents: Optional[Sequence[Document]] = None,\n service_context: Optional[ServiceContext] = None,\n **kwargs\n ) -> VectorStoreIndex:\n\n if documents is None and vector_store_type == \"SimpleVectorStore\":\n raise ValueError(\"documents must be provided for SimpleVectorStore\")\n\n vector_store_class = import_vector_store_class(vector_store_type)\n\n if documents is None:\n vector_store = vector_store_class(**kwargs)\n index = VectorStoreIndex.from_vector_store(\n vector_store=vector_store, service_context=service_context\n )\n else:\n if vector_store_type == \"LanceDBVectorStore\":\n kwargs[\"uri\"] = \"./.lancedb\" if \"uri\" not in kwargs else kwargs[\"uri\"]\n kwargs[\"table_name\"] = (\n \"vectors\" if \"table_name\" not in kwargs else kwargs[\"table_name\"]\n )\n vector_store = vector_store_class(**kwargs)\n storage_context = StorageContext.from_defaults(vector_store=vector_store)\n \n index = VectorStoreIndex.from_documents(\n documents=documents,\n storage_context=storage_context,\n service_context=service_context,\n show_progress=True,\n )\n\n return index" }, { "identifier": "read_pdf_as_documents", "path": "lyzr/utils/document_reading.py", "snippet": "def read_pdf_as_documents(\n input_dir: Optional[str] = None,\n input_files: Optional[List] = None,\n exclude_hidden: bool = True,\n filename_as_id: bool = True,\n recursive: bool = True,\n required_exts: Optional[List[str]] = None,\n **kwargs,\n) -> Sequence[Document]:\n file_extractor = {\".pdf\": LyzrPDFReader()}\n\n reader = SimpleDirectoryReader(\n input_dir=input_dir,\n exclude_hidden=exclude_hidden,\n file_extractor=file_extractor,\n input_files=input_files,\n filename_as_id=filename_as_id,\n recursive=recursive,\n required_exts=required_exts,\n **kwargs,\n )\n\n documents = reader.load_data()\n\n logger.info(f\"Found {len(documents)} 'documents'.\")\n return documents" }, { "identifier": "read_docx_as_documents", "path": "lyzr/utils/document_reading.py", "snippet": "def read_docx_as_documents(\n input_dir: Optional[str] = None,\n input_files: Optional[List] = None,\n exclude_hidden: bool = True,\n filename_as_id: bool = True,\n recursive: bool = True,\n required_exts: Optional[List[str]] = None,\n **kwargs,\n) -> Sequence[Document]:\n file_extractor = {\".docx\": LyzrDocxReader()}\n\n reader = SimpleDirectoryReader(\n input_dir=input_dir,\n exclude_hidden=exclude_hidden,\n file_extractor=file_extractor,\n input_files=input_files,\n filename_as_id=filename_as_id,\n recursive=recursive,\n required_exts=required_exts,\n **kwargs,\n )\n\n documents = reader.load_data()\n\n logger.info(f\"Found {len(documents)} 'documents'.\")\n return documents" }, { "identifier": "read_txt_as_documents", "path": "lyzr/utils/document_reading.py", "snippet": "def read_txt_as_documents(\n input_dir: Optional[str] = None,\n input_files: Optional[List] = None,\n exclude_hidden: bool = True,\n filename_as_id: bool = True,\n recursive: bool = True,\n required_exts: Optional[List[str]] = None,\n **kwargs,\n) -> Sequence[Document]:\n file_extractor = {\".txt\": LyzrTxtReader()}\n\n reader = SimpleDirectoryReader(\n input_dir=input_dir,\n exclude_hidden=exclude_hidden,\n file_extractor=file_extractor,\n input_files=input_files,\n filename_as_id=filename_as_id,\n recursive=recursive,\n required_exts=required_exts,\n **kwargs,\n )\n\n documents = reader.load_data()\n\n logger.info(f\"Found {len(documents)} 'documents'.\")\n return documents" }, { "identifier": "read_website_as_documents", "path": "lyzr/utils/document_reading.py", "snippet": "def read_website_as_documents(url: str) -> List[Document]:\n reader = LyzrWebsiteReader()\n documents = reader.load_data(url)\n return documents" }, { "identifier": "read_webpage_as_documents", "path": "lyzr/utils/document_reading.py", "snippet": "def read_webpage_as_documents(url: str) -> List[Document]:\n reader = LyzrWebPageReader()\n documents = reader.load_data(url)\n return documents" }, { "identifier": "read_youtube_as_documents", "path": "lyzr/utils/document_reading.py", "snippet": "def read_youtube_as_documents(\n urls: List[str] = None,\n) -> List[Document]:\n reader = LyzrYoutubeReader()\n documents = reader.load_data(urls)\n return documents" } ]

[ { "identifier": "Resolver", "path": "pydantic2_resolve/resolver.py", "snippet": "class Resolver:\n \"\"\"\n Entrypoint of a resolve action\n \"\"\"\n def __init__(\n self, \n loader_filters: Optional[Dict[Any, Dict[str, Any]]] = None, \n loader_instances: Optional[Dict[Any, Any]] = None,\n ensure_type=False,\n context: Optional[Dict[str, Any]] = None\n ):\n self.loader_instance_cache = {}\n\n self.ancestor_vars = {}\n self.ancestor_vars_checker = defaultdict(set) # expose_field_name: set(kls fullpath) if len > 1, raise error\n\n # for dataloader which has class attributes, you can assign the value at here\n self.loader_filters = loader_filters or {}\n\n # now you can pass your loader instance, Resolver will check `isinstance``\n if loader_instances and self._validate_loader_instance(loader_instances):\n self.loader_instances = loader_instances\n else:\n self.loader_instances = None\n\n self.ensure_type = ensure_type\n self.context = MappingProxyType(context) if context else None\n self.scan_data = {}\n\n\n def _add_expose_fields(self, target):\n \"\"\"\n 1. check whether expose to descendant existed\n 2. add fields into contextvars (ancestor_vars_checker)\n 2.1 check overwrite by another class(which is forbidden)\n 2.2 check field exists\n \"\"\"\n dct: Optional[dict] = getattr(target, const.EXPOSE_TO_DESCENDANT, None)\n # 1\n if dct:\n if type(dct) is not dict:\n raise AttributeError(f'{const.EXPOSE_TO_DESCENDANT} is not dict')\n\n # 2\n for field, alias in dct.items(): # eg: name, bar_name\n # 2.1\n self.ancestor_vars_checker[alias].add(util.get_kls_full_path(target.__class__))\n if len(self.ancestor_vars_checker[alias]) > 1:\n conflict_modules = ', '.join(list(self.ancestor_vars_checker[alias]))\n raise AttributeError(f'alias name conflicts, please check: {conflict_modules}')\n\n if not self.ancestor_vars.get(alias):\n self.ancestor_vars[alias] = contextvars.ContextVar(alias)\n \n try:\n val = getattr(target, field)\n except AttributeError:\n raise AttributeError(f'{field} does not existed')\n\n self.ancestor_vars[alias].set(val)\n \n\n def _build_ancestor_context(self):\n \"\"\"get values from contextvars and put into a dict\"\"\"\n return { k: v.get() for k, v in self.ancestor_vars.items()}\n \n\n def _validate_loader_instance(self, loader_instances: Dict[Any, Any]):\n for cls, loader in loader_instances.items():\n if not issubclass(cls, DataLoader):\n raise AttributeError(f'{cls.__name__} must be subclass of DataLoader')\n if not isinstance(loader, cls):\n raise AttributeError(f'{loader.__name__} is not instance of {cls.__name__}')\n return True\n \n\n def _execute_resolver_method(self, method):\n \"\"\"\n 1. inspect method, atttach context if declared in method\n 2. if params includes LoaderDepend, create instance and cache it.\n 2.1 create from DataLoader class\n 2.1.1 apply loader_filters into dataloader instance\n 2.2 ceate from batch_load_fn\n 3. execute method\n \"\"\"\n\n # >>> 1\n signature = inspect.signature(method)\n params = {}\n\n if signature.parameters.get('context'):\n if self.context is None:\n raise AttributeError('Resolver.context is missing')\n params['context'] = self.context\n\n if signature.parameters.get('ancestor_context'):\n if self.ancestor_vars is None:\n raise AttributeError(f'there is not class has {const.EXPOSE_TO_DESCENDANT} configed')\n params['ancestor_context'] = self._build_ancestor_context()\n\n # manage the creation of loader instances\n for k, v in signature.parameters.items():\n # >>> 2\n if isinstance(v.default, Depends):\n # Base: DataLoader or batch_load_fn\n Loader = v.default.dependency\n\n # check loader_instance first, if already defined in Resolver param, just take it.\n if self.loader_instances and self.loader_instances.get(Loader):\n loader = self.loader_instances.get(Loader)\n params[k] = loader\n continue\n\n # module.kls to avoid same kls name from different module\n cache_key = util.get_kls_full_path(v.default.dependency)\n hit = self.loader_instance_cache.get(cache_key)\n if hit:\n loader = hit\n else:\n # >>> 2.1\n # create loader instance \n if isclass(Loader):\n # if extra transform provides\n loader = Loader()\n\n filter_config = self.loader_filters.get(Loader, {})\n\n for field in util.get_class_field_annotations(Loader):\n # >>> 2.1.1\n # class ExampleLoader(DataLoader):\n # filtar_x: bool <--------------- set this field\n try:\n value = filter_config[field]\n setattr(loader, field, value)\n except KeyError:\n raise LoaderFieldNotProvidedError(f'{cache_key}.{field} not found in Resolver()')\n\n # >>> 2.2\n # build loader from batch_load_fn, filters config is impossible\n else:\n loader = DataLoader(batch_load_fn=Loader) # type:ignore\n\n self.loader_instance_cache[cache_key] = loader\n params[k] = loader\n\n # 3\n return method(**params)\n\n\n def _execute_post_method(self, method):\n signature = inspect.signature(method)\n params = {}\n\n if signature.parameters.get('context'):\n if self.context is None:\n raise AttributeError('Post.context is missing')\n params['context'] = self.context\n\n if signature.parameters.get('ancestor_context'):\n if self.ancestor_vars is None:\n raise AttributeError(f'there is not class has {const.EXPOSE_TO_DESCENDANT} configed')\n params['ancestor_context'] = self._build_ancestor_context()\n return method(**params)\n\n\n async def _resolve_obj_field(self, target, field, attr):\n \"\"\"\n resolve each single object field\n\n 1. validate the target field of resolver method existed.\n 2. exec methods\n 3. parse to target type and then continue resolve it\n 4. set back value to field\n \"\"\"\n\n # >>> 1\n target_attr_name = str(field).replace(const.PREFIX, '')\n\n if not hasattr(target, target_attr_name):\n raise ResolverTargetAttrNotFound(f\"attribute {target_attr_name} not found\")\n\n if self.ensure_type:\n if not attr.__annotations__:\n raise MissingAnnotationError(f'{field}: return annotation is required')\n\n # >>> 2\n val = self._execute_resolver_method(attr)\n while iscoroutine(val) or asyncio.isfuture(val):\n val = await val\n\n # >>> 3\n if not getattr(attr, const.HAS_MAPPER_FUNCTION, False): # defined in util.mapper\n val = util.try_parse_data_to_target_field_type(target, target_attr_name, val)\n\n val = await self._resolve(val)\n\n # >>> 4\n setattr(target, target_attr_name, val)\n\n\n async def _resolve(self, target: T) -> T:\n \"\"\" \n resolve object (pydantic, dataclass) or list.\n\n 1. iterate over elements if list\n 2. resolve object\n 2.1 resolve each single resolver fn and object fields\n 2.2 execute post fn\n \"\"\"\n\n # >>> 1\n if isinstance(target, (list, tuple)):\n await asyncio.gather(*[self._resolve(t) for t in target])\n\n # >>> 2\n if core.is_acceptable_instance(target):\n self._add_expose_fields(target)\n tasks = []\n # >>> 2.1\n resolve_list, attribute_list = core.iter_over_object_resolvers_and_acceptable_fields(target, self.scan_data)\n for field, attr in resolve_list:\n tasks.append(self._resolve_obj_field(target, field, attr))\n for field, attr in attribute_list:\n tasks.append(self._resolve(attr))\n\n await asyncio.gather(*tasks)\n\n # >>> 2.2\n # execute post methods, if context declared, self.context will be injected into it. \n for post_key in core.iter_over_object_post_methods(target, self.scan_data):\n post_attr_name = post_key.replace(const.POST_PREFIX, '')\n if not hasattr(target, post_attr_name):\n raise ResolverTargetAttrNotFound(f\"fail to run {post_key}(), attribute {post_attr_name} not found\")\n\n post_method = getattr(target, post_key)\n calc_result = self._execute_post_method(post_method)\n setattr(target, post_attr_name, calc_result)\n \n # finally, if post_default_handler is declared, run it.\n default_post_method = getattr(target, const.POST_DEFAULT_HANDLER, None)\n if default_post_method:\n self._execute_post_method(default_post_method)\n\n return target\n\n\n async def resolve(self, target: T) -> T:\n if isinstance(target, list) and target == []:\n return target\n\n self.scan_data = core.scan_and_store_required_fields(target)\n\n await self._resolve(target)\n return target " }, { "identifier": "LoaderDepend", "path": "pydantic2_resolve/resolver.py", "snippet": "def LoaderDepend( # noqa: N802\n dependency: Optional[Callable[..., Any]] = None,\n) -> Any:\n return Depends(dependency=dependency)" } ]

[ { "identifier": "CompetenceArea", "path": "dcm/dcm_core.py", "snippet": "class CompetenceArea(CompetenceElement):\n \"\"\"\n Represents a specific area within a competence aspect, containing various facets.\n\n Attributes:\n facets (List[CompetenceFacet]): A list of CompetenceFacet objects representing individual facets of this area.\n \"\"\"\n facets: List[CompetenceFacet] = field(default_factory=list)" }, { "identifier": "CompetenceAspect", "path": "dcm/dcm_core.py", "snippet": "class CompetenceAspect(CompetenceElement):\n \"\"\"\n Represents a broader category of competence, which includes various areas.\n\n Attributes:\n areas (List[CompetenceArea]): A list of CompetenceArea objects representing individual areas of this aspect.\n \"\"\"\n\n areas: List[CompetenceArea] = field(default_factory=list)\n credits: Optional[int] = None" }, { "identifier": "CompetenceElement", "path": "dcm/dcm_core.py", "snippet": "class CompetenceElement:\n \"\"\"\n A base class representing a generic competence element with common properties.\n\n Attributes:\n name (str): The name of the competence element.\n id (Optional[str]): An optional identifier for the competence element will be set to the name if id is None.\n url (Optional[str]): An optional URL for more information about the competence element.\n description (Optional[str]): An optional description of the competence element.\n color_code (str): A string representing a color code associated with the competence element.\n \"\"\"\n\n name: str\n id: Optional[str] = None\n url: Optional[str] = None\n description: Optional[str] = None\n color_code: Optional[str] = None\n\n def __post_init__(self):\n # Set the id to the the slug of the name if id is None\n if self.id is None:\n self.id = slugify(self.name)\n\n def as_html(self) -> str:\n \"\"\"\n convert me to html\n\n Returns:\n str: html markup\n \"\"\"\n html = f\"<h2>{self.name}</h2>\"\n if self.description:\n desc_html = markdown2.markdown(\n self.description, extras=[\"fenced-code-blocks\", \"tables\", \"spoiler\"]\n )\n html = html + \"\\n\" + desc_html\n return html\n\n def to_svg_node_config(self, url: str = None, **kwargs) -> SVGNodeConfig:\n \"\"\"\n convert me to an SVGNode Configuration\n\n Args:\n url(str): the url to use for clicking this svg node - if None use\n my configured url\n \"\"\"\n if url is None:\n url = self.url\n element_type = f\"{self.__class__.__name__}\"\n comment = f\"{element_type}:{self.description}\"\n svg_node_config = SVGNodeConfig(\n element_type=f\"{element_type}\",\n id=f\"{self.id}\",\n url=url,\n fill=self.color_code,\n title=self.name,\n comment=comment,\n **kwargs,\n )\n return svg_node_config" }, { "identifier": "CompetenceFacet", "path": "dcm/dcm_core.py", "snippet": "class CompetenceFacet(CompetenceElement):\n \"\"\"\n Represents a specific facet of a competence aspect, inheriting from CompetenceElement.\n\n This class can include additional properties or methods specific to a competence facet.\n \"\"\"" }, { "identifier": "CompetenceLevel", "path": "dcm/dcm_core.py", "snippet": "class CompetenceLevel(CompetenceElement):\n \"\"\"\n Defines a specific level of competence within the framework.\n\n Attributes:\n level (int): level number starting from 1 as the lowest and going up to as many level as defined for the CompetenceTree\n icon(str): the name of a google mdi icon to be shown for this level\n utf8_icon(str): utf-8 char string to be used as icon\n \"\"\"\n\n level: int = 1\n icon: Optional[str] = None\n utf8_icon: Optional[str] = None" }, { "identifier": "CompetenceTree", "path": "dcm/dcm_core.py", "snippet": "class CompetenceTree(CompetenceElement, YamlAble[\"CompetenceTree\"]):\n \"\"\"\n Represents the entire structure of competencies, including various aspects and levels.\n\n Attributes:\n competence_aspects (List[CompetenceAspect]): A list of CompetenceAspect objects.\n competence_levels (List[CompetenceLevel]): A list of CompetenceLevel objects representing the different levels in the competence hierarchy.\n element_names (Dict[str, str]): A dictionary holding the names for tree, aspects, facets, and levels. The key is the type (\"tree\", \"aspect\", \"facet\", \"level\").\n \"\"\"\n\n lookup_url: Optional[str] = None\n aspects: List[CompetenceAspect] = field(default_factory=list)\n levels: List[CompetenceLevel] = field(default_factory=list)\n element_names: Dict[str, str] = field(default_factory=dict)\n\n def __post_init__(self):\n \"\"\"\n initalize the path variables of my hierarchy\n \"\"\"\n super().__post_init__()\n self.path = self.id\n # Loop through each competence aspect and set their paths and parent references\n for aspect in self.aspects:\n aspect.competence_tree = self\n aspect.path = f\"{self.id}/{aspect.id}\"\n for area in aspect.areas:\n area.competence_tree = self\n area.aspect = aspect\n area.path = f\"{self.id}/{aspect.id}/{area.id}\"\n for facet in area.facets:\n facet.competence_tree = self\n facet.area = area\n facet.path = f\"{self.id}/{aspect.id}/{area.id}/{facet.id}\"\n\n @classmethod\n def required_keys(cls) -> Tuple:\n keys = {\"name\", \"id\", \"url\", \"description\", \"element_names\"}\n return keys\n\n def lookup_by_path(\n self, path: str, lenient: bool = True\n ) -> Optional[CompetenceElement]:\n \"\"\"\n Look up and return a competence element (tree,aspect of facet)\n based on the given path.\n\n The path is expected to be in the format \"tree_id/aspect_id/facet_id\".\n This method parses the path and retrieves the corresponding competence aspect or facet.\n\n Args:\n path (str): The path in the format \"tree_id/aspect_id/facet_id\".\n\n lenient(bool): if not lenient raise Exceptions for invalid paths and ids\n Returns:\n Optional[CompetenceElement]: The competence aspect or facet corresponding to the given path.\n \"\"\"\n\n def handle_error(msg):\n if not lenient:\n raise ValueError(msg)\n\n parts = path.split(\"/\")\n if len(parts) < 1:\n return None\n\n tree_id = parts[0]\n if tree_id != self.id:\n handle_error(f\"invalid tree_id for lookup {tree_id}\")\n return None\n if len(parts) == 1:\n return self\n if len(parts) > 1:\n aspect_id = parts[1]\n # Retrieve the aspect\n aspect = next((aspect for aspect in self.aspects if aspect.id==aspect_id), None)\n if aspect:\n if len(parts) == 2:\n return aspect\n if len(parts) > 2:\n area_id = parts[2]\n area = next((area for area in aspect.areas if area.id == area_id), None)\n if area:\n if len(parts) == 3:\n return area\n if len(parts) > 3:\n facet_id = parts[3]\n facet = next(\n (facet for facet in area.facets if facet.id == facet_id), None\n )\n if facet:\n return facet\n handle_error(f\"invalid path for lookup {path}\")\n return None\n\n def to_pretty_json(self):\n \"\"\"\n Converts the CompetenceTree object to a pretty JSON string, handling null values.\n \"\"\"\n json_str = self.to_json()\n json_dict = json.loads(json_str)\n\n def remove_none_values(data):\n \"\"\"\n Recursively removes keys with None values from a dictionary, list, or nested structure.\n \"\"\"\n if isinstance(data, dict):\n return {\n k: remove_none_values(v) for k, v in data.items() if v is not None\n }\n elif isinstance(data, list):\n return [remove_none_values(item) for item in data]\n return data\n\n none_free_dict = remove_none_values(json_dict)\n null_free_json_str = json.dumps(none_free_dict, indent=2)\n return null_free_json_str\n\n def add_legend(self, svg: SVG) -> None:\n \"\"\"\n Add a legend to the SVG explaining the color codes for levels and aspects.\n Args:\n svg (SVG): The SVG object to which the legend will be added.\n \"\"\"\n # Starting x position for the legends, starting 10 pixels from the left edge\n x_start = 10\n # y position for the legends, starting 20 pixels from the bottom edge\n y = svg.config.total_height - svg.config.legend_height + 20\n # Width and height of each legend color box\n box_width, box_height = 30, 20\n # Padding between legend items and between the color box and the text\n padding = 5\n\n # Add the competence level legend\n level_items = [(level.color_code, level.name) for level in self.levels]\n svg.add_legend_column(\n level_items,\n self.element_names.get(\"level\", \"Level\"),\n x_start,\n y,\n box_width,\n box_height,\n )\n\n # Calculate the x position for the aspect legend based on the width of the level legend\n x_aspect_start = (\n x_start\n + box_width\n + padding\n + max(svg.get_text_width(level.name) for level in self.levels)\n + padding\n )\n\n # Add the competence aspect legend\n aspect_items = [(aspect.color_code, aspect.name) for aspect in self.aspects]\n svg.add_legend_column(\n aspect_items,\n self.element_names.get(\"aspect\", \"Aspect\"),\n x_aspect_start,\n y,\n box_width,\n box_height,\n )" } ]

[ { "identifier": "Project", "path": "app/core/models/project.py", "snippet": "class Project:\r\n path: str # 工程目录（相对位置）\r\n name: str # 工程名称\r\n\r\n def __init__(self, name: str, existed_err=False):\r\n self.name = name\r\n self.path = os.path.join(Core.PROJ_DIR, name)\r\n try:\r\n os.makedirs(self.path)\r\n info(f'已创建目录 {self.path}')\r\n except OSError as e: # directory existed\r\n if existed_err:\r\n raise e\r\n\r\n def _prepare(self):\r\n info(f'正在预处理 \"{self.name}\" 的音频')\r\n tmp_path = os.path.join(self.path, 'source.wav')\r\n tmp_file = test_files(tmp_path)\r\n src_file = test_files(\r\n os.path.join(self.path, 'source.mp4'),\r\n os.path.join(self.path, f'{self.name}.mp4'),\r\n os.path.join(self.path, f'{self.name}.mp3')\r\n )\r\n if tmp_file:\r\n info(f'找到了临时文件 \"{tmp_file}\"，跳过预处理')\r\n elif src_file:\r\n info(f'找到了 \"{src_file}\"，开始预处理')\r\n if check_ffmpeg() != FFMpegStatus.READY:\r\n raise EnvironmentError('FFMpeg尚未安装')\r\n proc: Popen[bytes] = ffmpeg.input(src_file) \\\r\n .output(tmp_path, format='wav', acodec='pcm_s16le', ac=1, ar=16000) \\\r\n .overwrite_output() \\\r\n .run_async(pipe_stdout=True, pipe_stderr=True)\r\n out, err = proc.communicate()\r\n return_code = proc.wait()\r\n if return_code != 0:\r\n raise ChildProcessError('无法提取音频')\r\n info('预处理成功')\r\n else:\r\n raise FileNotFoundError(f'请将同名 mp4 文件放置在 {self.path}')\r\n\r\n def delete(self):\r\n \"\"\"Delete project folder\"\"\"\r\n shutil.rmtree(self.path)\r\n\r\n def transcribe(self, opt: TranscribeOpt):\r\n \"\"\"\r\n transcribe wav audio to SRT\r\n\r\n :return: transcribe result file path\r\n \"\"\"\r\n self._prepare()\r\n\r\n target_file = opt.make_srt_filepath(name=self.name, path=self.path)\r\n if os.path.isfile(target_file):\r\n info(f'文件 \"{target_file}\" 已存在，跳过听写')\r\n return target_file\r\n\r\n info(f'使用 {opt}')\r\n match opt.backend:\r\n # case Engine.CPP_CPU:\r\n # ext = ''\r\n # if opt.compress_ratio_threshold:\r\n # ext += f' -et {opt.compress_ratio_threshold} '\r\n # if opt.prompt_name:\r\n # ext += f' --prompt \"{DB.PROMPTS[opt.prompt_name]}\" '\r\n # if opt.speedup:\r\n # ext += f' -su '\r\n # if opt.ss and opt.t:\r\n # ss = opt.ss * 1000\r\n # t = opt.t * 1000\r\n # if opt.speedup:\r\n # ss /= 2\r\n # t /= 2\r\n # ext += f' -ot {ss} -d {t} '\r\n # cmd = f\".\\\\whisper\\\\main.exe -m data/whisper_model/ggml-large-v2.bin \" \\\r\n # f\"-pp -osrt -l {opt.lang} -t 8 {ext} -f {self.path}/source.wav -of {target_file.rstrip('.srt')}\"\r\n # print(f'运行: {cmd}')\r\n # proc = subprocess.Popen(cmd, shell=True, cwd=os.getcwd(), stdout=subprocess.PIPE)\r\n # for line in proc.stdout:\r\n # print(line.decode(Core.CODEC).rstrip())\r\n case 'py-gpu' | 'py-cpu':\r\n info('正在加载模型')\r\n import whisper\r\n import torch\r\n model = whisper.load_model(opt.model, download_root='whisper_model', device='cpu')\r\n if opt.quantize:\r\n info('正在量化模型')\r\n model = torch.quantization.quantize_dynamic(\r\n model, {torch.nn.Linear}, dtype=torch.qint8\r\n )\r\n if opt.backend == 'py-gpu':\r\n info('正在加载至显卡')\r\n model.to('cuda')\r\n result = model.transcribe(\r\n audio=f'{self.path}/source.wav',\r\n language=opt.lang,\r\n compression_ratio_threshold=opt.compress_ratio_threshold,\r\n initial_prompt=Consts.PROMPTS[opt.prompt_name],\r\n verbose=True,\r\n )\r\n\r\n del model\r\n torch.cuda.empty_cache()\r\n\r\n segments = result['segments']\r\n srt = SRTFile(source=segments)\r\n srt.dump(target_file)\r\n case _:\r\n raise NotImplementedError(f'{opt.backend} 引擎尚未支持')\r\n\r\n info('听写完成')\r\n\r\n def translate(self, opt: TranscribeOpt, vocab=None):\r\n srt = SRTFile(source=opt.make_srt_filepath(self.name, self.path))\r\n srt.translate(vocab=vocab)\r\n\r\n @classmethod\r\n def list(cls) -> List[str]:\r\n \"\"\"list all projects\"\"\"\r\n names = os.listdir(Core.PROJ_DIR)\r\n directories = [name for name in names if os.path.isdir(os.path.join(Core.PROJ_DIR, name))]\r\n directories = sort_titles(directories)\r\n return directories\r\n\r\n @classmethod\r\n def bulk_create(cls, targets: List[tuple]):\r\n info(f'正在创建 {len(targets)} 个工程')\r\n for proj_name, filepath in targets:\r\n try:\r\n proj = Project(proj_name, existed_err=True)\r\n except OSError:\r\n info(f'\"{proj_name}\" 已存在，不再创建')\r\n continue\r\n\r\n if filepath:\r\n dst_filepath = os.path.join(proj.path, os.path.basename(filepath))\r\n info(f'正在将 {filepath} 复制到 {dst_filepath}')\r\n shutil.copy(filepath, dst_filepath)\r\n info('复制完毕')\r" }, { "identifier": "TranscribeOpt", "path": "app/core/models/project.py", "snippet": "class TranscribeOpt:\r\n \"\"\"\r\n :param backend: whisper implementation\r\n :param model: whisper model name\r\n :param quantize: whisper model quantization switch\r\n :param ss: transcribe start second\r\n :param t: transcribe time duration(second)\r\n :param compress_ratio_threshold: 2.4 ~ 3 is recommended, segments higher than this will be re-inferenced\r\n :param speedup: double speed, decrease quality\r\n :param prompt_name: name\r\n \"\"\"\r\n backend: str\r\n model: str\r\n quantize: bool\r\n lang: Optional[str]\r\n ss: int # TODO: implement in whisper.py mode\r\n t: int # TODO: implement in whisper.py mode\r\n compress_ratio_threshold: float\r\n speedup: bool # TODO: implement in whisper.py mode\r\n prompt_name: str\r\n\r\n def make_srt_filepath(self, name: str, path: str) -> str:\r\n return f'{path}/' \\\r\n f'{name}' \\\r\n f'[{self.backend}]' \\\r\n f'[{self.model}]' \\\r\n f'[q{int(self.quantize)}]' \\\r\n f'[L{self.lang or \"auto\"}]' \\\r\n f'[t{\"FULL\" if not (self.ss and self.t) else f\"{self.ss}-{self.ss + self.t}\"}]' \\\r\n f'[e{self.compress_ratio_threshold}]' \\\r\n f'[s{int(self.speedup)}]' \\\r\n f'[p{self.prompt_name or \"-\"}]' \\\r\n f'.srt'\r" }, { "identifier": "info", "path": "app/core/utils/generic.py", "snippet": "def info(text):\r\n print(f\"ℹ️{text}\")\r" }, { "identifier": "AutoLabel", "path": "app/ui/components/label.py", "snippet": "class AutoLabel(QLabel):\r\n def __init__(self, text, parent=None, elide_mode=None):\r\n super().__init__(text, parent)\r\n self._raw_text = text\r\n self._elide_mode = elide_mode if elide_mode is not None else Qt.ElideMiddle\r\n self._eliding = False\r\n\r\n def _get_elided_text(self):\r\n return self.fontMetrics().elidedText(self._raw_text, self._elide_mode, self.width())\r\n\r\n def resizeEvent(self, event: QtGui.QResizeEvent):\r\n super().resizeEvent(event)\r\n if self._eliding:\r\n return\r\n\r\n self._eliding = True\r\n super().setText(self._get_elided_text())\r\n self._eliding = False\r\n\r\n def setText(self, text):\r\n self._raw_text = text\r\n super().setText(self._get_elided_text())\r" }, { "identifier": "cfg", "path": "app/ui/config.py", "snippet": "class Engine(Enum):\r\nclass TranscribeModel(Enum):\r\nclass UILang(Enum):\r\nclass TranscribeLang(Enum):\r\nclass Config(QConfig):\r\n PY_CPU = \"py-cpu\"\r\n PY_GPU = \"py-gpu\"\r\n CPP_CPU = \"cpp-cpu\"\r\n LARGE_V2 = \"large-v2\"\r\n MEDIUM = \"medium\"\r\n SMALL = \"small\"\r\n BASE = \"base\"\r\n TINY = \"tiny\"\r\n CHINESE_SIMPLIFIED = \"chs\"\r\n CHINESE_TRADITIONAL = \"cht\"\r\n ENGLISH = \"en\"\r\n AUTO = \"auto\"\r\n AUTO = None\r\n def options(cls):\r" }, { "identifier": "CONTAINER_MARGINS", "path": "app/ui/const.py", "snippet": "CONTAINER_MARGINS = (32, 64, 32, 32)\r" }, { "identifier": "run_in_thread", "path": "app/ui/utils.py", "snippet": "def run_in_thread(func):\r\n @functools.wraps(func)\r\n def wrapper(*args, **kwargs):\r\n if args and kwargs:\r\n t = threading.Thread(target=func, args=args, kwargs=kwargs)\r\n elif args:\r\n t = threading.Thread(target=func, args=args)\r\n else:\r\n t = threading.Thread(target=func)\r\n t.daemon = True\r\n t.start()\r\n return t\r\n\r\n return wrapper\r" }, { "identifier": "clear_layout", "path": "app/ui/utils.py", "snippet": "def clear_layout(layout):\r\n while layout.count():\r\n child = layout.takeAt(0)\r\n if child.widget():\r\n child.widget().deleteLater()\r\n elif child.layout():\r\n clear_layout(child.layout())\r" }, { "identifier": "open_folder", "path": "app/ui/utils.py", "snippet": "def open_folder(folder_path):\r\n \"\"\"Open specific folder in file explorer application\"\"\"\r\n if os.name == 'nt': # Windows\r\n os.startfile(folder_path)\r\n elif os.name == 'posix': # Linux, macOS, etc.\r\n subprocess.Popen(['xdg-open', folder_path])\r\n else:\r\n raise OSError(f'Unsupported platform: {os.name}')\r" }, { "identifier": "SubtitleWindow", "path": "app/ui/windows/subtitle_window.py", "snippet": "class SubtitleWindow(QDialog, FramelessWindow):\n def __init__(self, filepath: str, parent=None):\n super().__init__(parent)\n self.srt_file = SRTFile(filepath)\n self.hBoxLayout = QVBoxLayout(self)\n self.tableView = TableWidget(self)\n self.saveButton = QPushButton(\"Save\", self)\n self.saveButton.clicked.connect(self._save_subtitle_file)\n\n self.hBoxLayout.setContentsMargins(*CONTAINER_MARGINS)\n self.hBoxLayout.addWidget(self.tableView)\n self.hBoxLayout.addWidget(self.saveButton)\n\n self.init_window()\n self._load_subtitle_file()\n\n def _load_subtitle_file(self):\n self.tableView.setWordWrap(False)\n self.tableView.setRowCount(len(self.srt_file.entries))\n self.tableView.setColumnCount(3)\n for i, entry in enumerate(self.srt_file.entries):\n self.tableView.setItem(i, 0, QTableWidgetItem(entry.index))\n self.tableView.setItem(i, 1, QTableWidgetItem(entry.time))\n self.tableView.setItem(i, 2, QTableWidgetItem(entry.text))\n\n self.tableView.verticalHeader().hide()\n self.tableView.setHorizontalHeaderLabels(['Index', 'Time', 'Text'])\n self.tableView.resizeColumnsToContents()\n\n def _save_subtitle_file(self):\n for i in range(self.tableView.rowCount()):\n self.srt_file.entries[i].index = self.tableView.item(i, 0).text()\n self.srt_file.entries[i].time = self.tableView.item(i, 1).text()\n self.srt_file.entries[i].text = self.tableView.item(i, 2).text()\n\n self.srt_file.dump()\n\n def init_window(self):\n self.setWindowTitle(f'编辑 {self.srt_file.filepath}')\n self.resize(625, 700)\n self._set_qss()\n\n def _set_qss(self):\n color = 'dark' if isDarkTheme() else 'light'\n with open(res_dir(f'app/ui/resource/qss/{color}/style.qss'), encoding='utf-8') as f:\n self.setStyleSheet(f.read())" } ]

[ { "identifier": "constants", "path": "ols/src/constants.py", "snippet": "SUMMARIZATION_TEMPLATE = \"\"\"\nThe following context contains several pieces of documentation. Please summarize the context for the user.\nDocumentation context:\n{context_str}\n\nSummary:\n\n\"\"\"\nSUMMARY_TASK_BREAKDOWN_TEMPLATE = (\n \"\"\"\nThe following documentation contains a task list. Your job is to extract the list of tasks. \"\"\"\n \"\"\"If the user-supplied query seems unrelated to the list of tasks, please reply that you do not know what to do with the query and the summary documentation. \"\"\"\n \"\"\"Use only the supplied content and extract the task list.\n\nSummary document:\n{context_str}\n\nUser query:\n{query_str}\n\nWhat are the tasks?\n\"\"\"\n)\nTASK_PERFORMER_PROMPT_TEMPLATE = \"\"\"\nInstructions:\n- You are a helpful assistant.\n- You are an expert in Kubernetes and OpenShift.\n- Respond to questions about topics other than Kubernetes and OpenShift with: \"I can only answer questions about Kubernetes and OpenShift\"\n- Refuse to participate in anything that could harm a human.\n- Your job is to look at the following description and provide a response.\n- Base your answer on the provided task and query and not on prior knowledge.\n\nTASK:\n{task}\nQUERY:\n{query}\n\nQuestion:\nDoes the above query contain enough background information to complete the task? Provide a yes or no answer with explanation.\n\nResponse:\n\"\"\"\nTASK_REPHRASER_PROMPT_TEMPLATE = \"\"\"\nInstructions:\n- You are a helpful assistant.\n- Your job is to combine the information from the task and query into a single, new task.\n- Base your answer on the provided task and query and not on prior knowledge.\n\nTASK:\n{task}\nQUERY:\n{query}\n\nPlease combine the information from the task and query into a single, new task.\n\nResponse:\n\"\"\"\nYES_OR_NO_CLASSIFIER_PROMPT_TEMPLATE = \"\"\"\nInstructions:\n- determine if a statement is a yes or a no\n- return a 1 if the statement is a yes statement\n- return a 0 if the statement is a no statement\n- return a 9 if you cannot determine if the statement is a yes or no\n\nExamples:\nStatement: Yes, that sounds good.\nResponse: 1\n\nStatement: No, I don't think that is wise.\nResponse: 0\n\nStatement: Apples are red.\nResponse: 9\n\nStatement: {statement}\nResponse:\n\"\"\"\nQUESTION_VALIDATOR_PROMPT_TEMPLATE = \"\"\"\nInstructions:\n- You are a question classifying tool\n- You are an expert in kubernetes and openshift\n- Your job is to determine if a question is about kubernetes or openshift and to provide a one-word response\n- If a question is not about kubernetes or openshift, answer with only the word INVALID\n- If a question is about kubernetes or openshift, answer with the word VALID\n- If a question is not about creating kubernetes or openshift yaml, answer with the word NOYAML\n- If a question is about creating kubernetes or openshift yaml, add the word YAML\n- Use a comma to separate the words\n- Do not provide explanation, only respond with the chosen words\n\nExample Question:\nCan you make me lunch with ham and cheese?\nExample Response:\nINVALID,NOYAML\n\nExample Question:\nWhy is the sky blue?\nExample Response:\nINVALID,NOYAML\n\nExample Question:\nCan you help configure my cluster to automatically scale?\nExample Response:\nVALID,NOYAML\n\nExample Question:\nplease give me a vertical pod autoscaler configuration to manage my frontend deployment automatically. Don't update the workload if there are less than 2 pods running.\nExample Response:\nVALID,YAML\n\nQuestion:\n{query}\nResponse:\n\"\"\"\nYAML_GENERATOR_PROMPT_TEMPLATE = \"\"\"\nInstructions:\n- Produce only a yaml response to the user request\n- Do not augment the response with markdown or other formatting beyond standard yaml formatting\n- Only provide a single yaml object containg a single resource type in your response, do not provide multiple yaml objects\n\nUser Request: {query}\n\"\"\"\nYAML_GENERATOR_WITH_HISTORY_PROMPT_TEMPLATE = \"\"\"\nInstructions:\n- Produce only a yaml response to the user request\n- Do not augment the response with markdown or other formatting beyond standard yaml formatting\n- Only provide a single yaml object containg a single resource type in your response, do not provide multiple yaml objects\n\nHere is the history of the conversation so far, you may find this relevant to the user request below:\n\n{history}\n\nUser Request: {query}\n\"\"\"\nPROVIDER_BAM = \"bam\"\nPROVIDER_OPENAI = \"openai\"\nPROVIDER_WATSONX = \"watsonx\"\nPROVIDER_TGI = \"tgi\"\nPROVIDER_OLLAMA = \"ollama\"\nTEI_EMBEDDING_MODEL = \"BAAI/bge-base-en-v1.5\"\nGRANITE_13B_CHAT_V1 = \"ibm/granite-13b-chat-v1\"\nGRANITE_13B_CHAT_V2 = \"ibm/granite-13b-chat-v2\"\nGRANITE_20B_CODE_INSTRUCT_V1 = \"ibm/granite-20b-code-instruct-v1\"\nGPT35_TURBO_1106 = \"gpt-3.5-turbo-1106\"\nGPT35_TURBO = \"gpt-3.5-turbo\"\nPRODUCT_INDEX = \"product\"\nPRODUCT_DOCS_PERSIST_DIR = \"./vector-db/ocp-product-docs\"\nSUMMARY_INDEX = \"summary\"\nSUMMARY_DOCS_PERSIST_DIR = \"./vector-db/summary-docs\"\nIN_MEMORY_CACHE = \"in-memory\"\nIN_MEMORY_CACHE_MAX_ENTRIES = 1000\nREDIS_CACHE = \"redis\"\nREDIS_CACHE_HOST = \"redis-stack.ols.svc\"\nREDIS_CACHE_PORT = 6379\nREDIS_CACHE_MAX_MEMORY = \"500mb\"\nREDIS_CACHE_MAX_MEMORY_POLICY = \"allkeys-lru\"" }, { "identifier": "config", "path": "ols/utils/config.py", "snippet": "def load_empty_config() -> None:\ndef load_config_from_env() -> None:" }, { "identifier": "Logger", "path": "ols/utils/logger.py", "snippet": "class Logger:\n \"\"\"This class is a simple wrapper around the Python logging function.\n\n Usage:\n\n # Simple usage\n\n logger = Logger().logger\n\n logger.debug('Debug message')\n logger.info('Info message')\n logger.warning('Warning message')\n logger.error('Error message')\n logger.critical('Critical message')\n\n # To disable logging to file set logfile to None\n\n logger = Logger(logfile=None).logger\n\n # If want to pass the name of the function generating the message\n # you may use the \"inspect\" library and generate the message as follows\n\n self.logger.debug(f\"[{inspect.stack()[0][3]}] Message here.\")\n\n # When using on a class that may already have another instance\n\n self.logger = logger if logger else Logger(show_message=False).logger\n\n \"\"\"\n\n def __init__(\n self,\n logger_name: str = \"default\",\n log_level: str = logging.getLevelName(logging.INFO),\n logfile: str | None = None,\n show_message: bool = False,\n ):\n \"\"\"Initializes the Logger instance.\n\n Args:\n logger_name: The name of the logger instance.\n log_level: The logging level for general logging verbosity.\n logfile: The path to the log file. Set to `None` to disable file logging.\n show_message: Whether to display a message about setting logging levels.\n\n Note:\n - The default values can be overridden using environment variables `LOG_LEVEL`\n or `LOG_LEVEL_CONSOLE` and `LOG_LEVEL_FILE`.\n - To set logfile name set `LOG_FILE_NAME`\n - To override logfile maximum size set `LOG_FILE_SIZE`\n \"\"\"\n msg = \"\"\"\n ############################################################################\n Set LOG_LEVEL or LOG_LEVEL_CONSOLE and LOG_LEVEL_FILE environment variable (e.g., INFO, DEBUG)\n to control general logging verbosity or console/file specific logging level\n ############################################################################\n \"\"\"\n if show_message:\n print(msg)\n\n # Load the dotenv configuration in case config class has not been used\n dotenv.load_dotenv()\n\n self.logger_name = logger_name\n self.log_level = os.getenv(\"LOG_LEVEL\", log_level)\n self.log_level_console = os.getenv(\"LOG_LEVEL_CONSOLE\", self.log_level)\n self.log_level_file = os.getenv(\"LOG_LEVEL_FILE\", self.log_level)\n _logfile = os.getenv(\"LOG_FILE_NAME\")\n self.logfile = _logfile if _logfile else logfile\n self.logfile_maxSize = int(os.getenv(\"LOG_FILE_SIZE\", (1048576 * 100)))\n self.logfile_backupCount = 3\n\n self.set_handlers()\n\n def set_handlers(self) -> None:\n \"\"\"Sets formatting, handlers and logging levels.\"\"\"\n self.logger = logging.getLogger(self.logger_name)\n self.logger.setLevel(self.log_level)\n\n formatter = logging.Formatter(\n \"%(asctime)s [%(filename)s:%(lineno)d] %(levelname)s: %(message)s\"\n )\n\n # console logging handler\n console_handler = logging.StreamHandler()\n console_handler.setLevel(self.log_level_console)\n console_handler.setStream(sys.stdout)\n console_handler.setFormatter(formatter)\n\n self.logger.addHandler(console_handler)\n\n # file logging handler (if not disabled)\n if self.logfile is not None:\n file_handler = RotatingFileHandler(\n self.logfile,\n maxBytes=self.logfile_maxSize,\n backupCount=self.logfile_backupCount,\n )\n file_handler.setLevel(self.log_level_file)\n file_handler.setFormatter(formatter)\n\n self.logger.addHandler(file_handler)" } ]

[ { "identifier": "ElasticsearchServer", "path": "component/pipelines/es.py", "snippet": "class ElasticsearchServer:\n def __init__(self):\n self.client = Elasticsearch(\n ES_URL,\n verify_certs=False,\n )\n self.embedding = Embeddings()\n self.es = ElasticsearchStore(\n index_name='audit_index',\n embedding=self.embedding,\n es_connection=self.client,\n )\n\n def create_index(self, index_name: str):\n if not self.client.indices.exists(index=index_name):\n dims = len(self.embedding.embed_query(\"test\"))\n mapping = _default_knn_mapping(dims)\n self.client.indices.create(index=index_name, body={\"mappings\": mapping})\n logger.info(f\"Successfully Created Index: {index_name}!\")\n else:\n logger.info(f\"Index: {index_name} already exists!\")\n\n def doc_upload(self, index_name: str, data_url: str):\n self.create_index(index_name)\n\n docs = []\n for root, dirs, files in os.walk(data_url):\n for file in tqdm(files):\n file_path = os.path.join(root, file)\n res = load_document(file_path)\n if res:\n self.es.add_documents(res)\n logger.info(f\"Successfully inserted document {res[0].metadata}!\")\n logger.info(\"Successfully inserted documents!\")\n\n def doc_search(\n self, method: str, query: str, top_k: int, knn_boost: float, index_name: str\n ) -> List[Dict]:\n result = []\n query_vector = self.embedding.embed_query(query)\n if method == \"knn\":\n query_body = generate_knn_query(vec=query_vector, size=top_k)\n elif method == \"hybrid\":\n query_body = generate_hybrid_query(text=query, vec=query_vector, size=top_k, knn_boost=knn_boost)\n else:\n query_body = generate_search_query(vec=query_vector, size=top_k)\n\n response = self.client.search(index=index_name, body=query_body)\n hits = [hit for hit in response[\"hits\"][\"hits\"]]\n for i in hits:\n result.append(\n {\n \"content\": i[\"_source\"][\"text\"],\n 'source': i[\"_source\"][\"metadata\"][\"source\"],\n 'score': i[\"_score\"]\n }\n )\n return result\n\n def delete(self, index_name):\n if self.client.indices.exists(index=index_name):\n self.client.indices.delete(index=index_name)\n logger.info(f\"Successfully Deleted Index: {index_name}!\")" }, { "identifier": "handle_response", "path": "component/pipelines/utils.py", "snippet": "def handle_response(messages, temperature, history_len, message_placeholder):\n full_response = \"\"\n openai.api_key = 'xxxx'\n openai.api_base = BAICHUAN_URL\n for response in openai.ChatCompletion.create(\n model=\"baichuan\",\n messages=messages[-history_len * 2 - 1:],\n temperature=temperature,\n stream=True,\n ):\n full_response += response.choices[0].delta.get(\"content\", \"\")\n message_placeholder.markdown(full_response + \"▌\")\n message_placeholder.markdown(full_response)\n return full_response" }, { "identifier": "create_message", "path": "component/pipelines/utils.py", "snippet": "def create_message(role, content, reference=None):\n message = {\"role\": role, \"content\": content}\n if reference is not None:\n message[\"reference\"] = reference\n return message" }, { "identifier": "KNOWLEDGE_PROMPT", "path": "component/pipelines/prompt.py", "snippet": "KNOWLEDGE_PROMPT = \"\"\"\n你是由南京审计大学智能审计团队研发的‘审元’大模型，目前还在不断完善中。\n如果不是询问身份信息就正常根据下面指令回答。\n<指令>请仔细阅读以下已知信息，并根据已知内容以专业的方式回答提出的问题。并且满足以下要求：\n1.你的任务是从已知信息中找到问题的答案，而不是生成新的信息。\n2.回答应符合逻辑，且答案内不能出现大量重复内容。\n2.如果已知信息中明确包含问题对应的答案，请直接提供，并且参考第二条。如果已知信息中没有答案，或者答案不明确，请回答“无法根据已知信息回答该问题”。\n3.请避免在答案中添加任何编造的信息。所有回答请使用中文。\n</指令>\n<已知信息>{context}</已知信息>\n<问题>请回答:{query}</问题>\n\"\"\"" }, { "identifier": "CHAT_EXAMPLES", "path": "component/pipelines/prompt.py", "snippet": "CHAT_EXAMPLES = [\"公共工程项目跟踪审计概念是什么?\",\n \"王天朝收受了哪些贿赂？\",\n \"如何认定本罪的标准?\"]" } ]

[ { "identifier": "matrix_init", "path": "online_lru/rec_init.py", "snippet": "def matrix_init(key, shape, dtype=jnp.float32, normalization=1):\n return random.normal(key=key, shape=shape, dtype=dtype) / normalization" }, { "identifier": "truncated_normal_matrix_init", "path": "online_lru/rec_init.py", "snippet": "def truncated_normal_matrix_init(key, shape, dtype=jnp.float_, normalization=1):\n return random.truncated_normal(key, -2.0, 2.0, shape, dtype) / normalization" }, { "identifier": "theta_init", "path": "online_lru/rec_init.py", "snippet": "def theta_init(key, shape, max_phase, dtype=jnp.float32, log=True):\n u = random.uniform(key, shape=shape, dtype=dtype)\n theta = max_phase * u\n if log:\n theta = jnp.log(theta)\n return theta" }, { "identifier": "nu_init", "path": "online_lru/rec_init.py", "snippet": "def nu_init(key, shape, r_min, r_max, dtype=jnp.float32, log=True):\n u = random.uniform(key=key, shape=shape, dtype=dtype)\n nu = -0.5 * jnp.log(u * (r_max**2 - r_min**2) + r_min**2)\n if log:\n nu = jnp.log(nu)\n return nu" }, { "identifier": "gamma_log_init", "path": "online_lru/rec_init.py", "snippet": "def gamma_log_init(key, lamb, log=True):\n nu, theta = lamb\n if log:\n nu = jnp.exp(nu)\n theta = jnp.exp(theta)\n diag_lambda = jnp.exp(-nu + 1j * theta)\n return jnp.log(jnp.sqrt(1 - jnp.abs(diag_lambda) ** 2))" } ]

[ { "identifier": "RETURNX", "path": "models/transformer.py", "snippet": "class RETURNX(nn.Module):\n def __init__(self,):\n super().__init__()\n\n def forward(self, x, y): # x is the cropped, y is the foreign reference \n return x" }, { "identifier": "Transformer", "path": "models/transformer.py", "snippet": "class Transformer(nn.Module):\n def __init__(self, dim, depth, heads, dim_head, mlp_dim, dropout = 0.):\n super().__init__()\n self.layers = nn.ModuleList([])\n for _ in range(depth):\n self.layers.append(nn.ModuleList([\n DualPreNorm(dim, Attention(dim, heads = heads, dim_head = dim_head, dropout = dropout)),\n PreNorm(dim, FeedForward(dim, mlp_dim, dropout = dropout))\n ]))\n\n\n def forward(self, x, y): # x is the cropped, y is the foreign reference\n bs,c,h,w = x.size()\n\n # img to embedding\n x = x.view(bs,c,-1).permute(0,2,1)\n y = y.view(bs,c,-1).permute(0,2,1)\n\n for attn, ff in self.layers:\n x = attn(x, y) + x\n x = ff(x) + x\n\n x = x.view(bs,h,w,c).permute(0,3,1,2)\n return x" }, { "identifier": "Conv2d", "path": "models/base_blocks.py", "snippet": "class Conv2d(nn.Module):\n def __init__(self, cin, cout, kernel_size, stride, padding, residual=False, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.conv_block = nn.Sequential(\n nn.Conv2d(cin, cout, kernel_size, stride, padding),\n nn.BatchNorm2d(cout)\n )\n self.act = nn.ReLU()\n self.residual = residual\n\n def forward(self, x):\n out = self.conv_block(x)\n if self.residual:\n out += x\n return self.act(out)" }, { "identifier": "LayerNorm2d", "path": "models/base_blocks.py", "snippet": "class LayerNorm2d(nn.Module):\n def __init__(self, n_out, affine=True):\n super(LayerNorm2d, self).__init__()\n self.n_out = n_out\n self.affine = affine\n\n if self.affine:\n self.weight = nn.Parameter(torch.ones(n_out, 1, 1))\n self.bias = nn.Parameter(torch.zeros(n_out, 1, 1))\n\n def forward(self, x):\n normalized_shape = x.size()[1:]\n if self.affine:\n return F.layer_norm(x, normalized_shape, \\\n self.weight.expand(normalized_shape), \n self.bias.expand(normalized_shape)) \n else:\n return F.layer_norm(x, normalized_shape) " }, { "identifier": "FirstBlock2d", "path": "models/base_blocks.py", "snippet": "class FirstBlock2d(nn.Module):\n def __init__(self, input_nc, output_nc, norm_layer=nn.BatchNorm2d, nonlinearity=nn.LeakyReLU(), use_spect=False):\n super(FirstBlock2d, self).__init__()\n kwargs = {'kernel_size': 7, 'stride': 1, 'padding': 3}\n conv = spectral_norm(nn.Conv2d(input_nc, output_nc, **kwargs), use_spect)\n\n if type(norm_layer) == type(None):\n self.model = nn.Sequential(conv, nonlinearity)\n else:\n self.model = nn.Sequential(conv, norm_layer(output_nc), nonlinearity)\n\n def forward(self, x):\n out = self.model(x)\n return out " }, { "identifier": "DownBlock2d", "path": "models/base_blocks.py", "snippet": "class DownBlock2d(nn.Module):\n def __init__(self, input_nc, output_nc, norm_layer=nn.BatchNorm2d, nonlinearity=nn.LeakyReLU(), use_spect=False):\n super(DownBlock2d, self).__init__()\n kwargs = {'kernel_size': 3, 'stride': 1, 'padding': 1}\n conv = spectral_norm(nn.Conv2d(input_nc, output_nc, **kwargs), use_spect)\n pool = nn.AvgPool2d(kernel_size=(2, 2))\n\n if type(norm_layer) == type(None):\n self.model = nn.Sequential(conv, nonlinearity, pool)\n else:\n self.model = nn.Sequential(conv, norm_layer(output_nc), nonlinearity, pool)\n\n def forward(self, x):\n out = self.model(x)\n return out " }, { "identifier": "UpBlock2d", "path": "models/base_blocks.py", "snippet": "class UpBlock2d(nn.Module):\n def __init__(self, input_nc, output_nc, norm_layer=nn.BatchNorm2d, nonlinearity=nn.LeakyReLU(), use_spect=False):\n super(UpBlock2d, self).__init__()\n kwargs = {'kernel_size': 3, 'stride': 1, 'padding': 1}\n conv = spectral_norm(nn.Conv2d(input_nc, output_nc, **kwargs), use_spect)\n if type(norm_layer) == type(None):\n self.model = nn.Sequential(conv, nonlinearity)\n else:\n self.model = nn.Sequential(conv, norm_layer(output_nc), nonlinearity)\n\n def forward(self, x):\n out = self.model(F.interpolate(x, scale_factor=2))\n return out" }, { "identifier": "FFCADAINResBlocks", "path": "models/base_blocks.py", "snippet": "class FFCADAINResBlocks(nn.Module):\n def __init__(self, num_block, input_nc, feature_nc, norm_layer=nn.BatchNorm2d, nonlinearity=nn.LeakyReLU(), use_spect=False):\n super(FFCADAINResBlocks, self).__init__() \n self.num_block = num_block\n for i in range(num_block):\n model = FFCResnetBlock(input_nc, feature_nc, norm_layer, nonlinearity, use_spect)\n setattr(self, 'res'+str(i), model)\n\n def forward(self, x, z):\n for i in range(self.num_block):\n model = getattr(self, 'res'+str(i))\n x = model(x, z)\n return x " }, { "identifier": "Jump", "path": "models/base_blocks.py", "snippet": "class Jump(nn.Module):\n def __init__(self, input_nc, norm_layer=nn.BatchNorm2d, nonlinearity=nn.LeakyReLU(), use_spect=False):\n super(Jump, self).__init__()\n kwargs = {'kernel_size': 3, 'stride': 1, 'padding': 1}\n conv = spectral_norm(nn.Conv2d(input_nc, input_nc, **kwargs), use_spect)\n if type(norm_layer) == type(None):\n self.model = nn.Sequential(conv, nonlinearity)\n else:\n self.model = nn.Sequential(conv, norm_layer(input_nc), nonlinearity)\n\n def forward(self, x):\n out = self.model(x)\n return out " }, { "identifier": "FinalBlock2d", "path": "models/base_blocks.py", "snippet": "class FinalBlock2d(nn.Module):\n def __init__(self, input_nc, output_nc, use_spect=False, tanh_or_sigmoid='tanh'):\n super(FinalBlock2d, self).__init__()\n kwargs = {'kernel_size': 7, 'stride': 1, 'padding':3}\n conv = spectral_norm(nn.Conv2d(input_nc, output_nc, **kwargs), use_spect)\n if tanh_or_sigmoid == 'sigmoid':\n out_nonlinearity = nn.Sigmoid()\n else:\n out_nonlinearity = nn.Tanh() \n self.model = nn.Sequential(conv, out_nonlinearity)\n\n def forward(self, x):\n out = self.model(x)\n return out " } ]

[ { "identifier": "fptf", "path": "hiveline/models/fptf.py", "snippet": "def _remove_empty_keys(d):\ndef read_datetime(time_str):\ndef format_datetime(dt):\n def __init__(self, name=None, address=None, longitude=None, latitude=None, altitude=None):\n def to_dict(self):\n def to_json(self):\n def from_dict(json_str):\ndef location_from_json(data: dict | str | None):\n def __init__(self, id: str, name: str, location: Location = None, regions: list = None):\n def to_dict(self):\n def to_json(self):\n def from_json(json_str):\ndef station_from_json(data: dict | str | None):\n def __init__(self, id: str, station: Station, name: str, location: Location = None):\n def to_dict(self):\n def to_json(self):\n def from_json(json_str):\ndef stop_from_json(data: dict | str | None):\ndef place_from_json(data: dict | str | None):\n def __init__(self, id: str, name: str, stations: list[Station] = None):\n def to_dict(self):\n def to_json(self):\n def from_json(json_str):\ndef region_from_json(data: dict | str | None):\n def __init__(self, mode: str):\n def __str__(self):\n def __repr__(self):\n def to_string(self):\n def to_json(self):\n def from_string(mode):\n def __init__(self, id: str, name: str):\n def to_dict(self):\n def to_json(self):\n def from_json(json_str):\ndef operator_from_json(data: dict | str | None):\n def __init__(self, id: str, name: str, mode: Mode, routes: list, operator: Operator = None, sub_mode: str = None):\n def to_dict(self):\n def to_json(self):\n def from_json(json_str):\ndef line_from_json(data: dict | str | None):\n def __init__(self, id: str, line: Line, mode: Mode, stops: list[Station | Stop | Location], sub_mode: str = None):\n def to_dict(self):\n def to_json(self):\ndef route_from_json(data: dict | str | None):\n def __init__(self, arrival: int = None, departure: int = None):\n def to_dict(self):\n def to_json(self):\n def from_json(json_str):\n def __init__(self, id: str, route: Route, mode: Mode, sequence: list[ScheduleSequenceElement], starts,\n sub_mode=None):\n def to_dict(self):\n def to_json(self):\n def from_json(json_str):\ndef schedule_from_json(data: dict | str | None):\n def __init__(self, stop: Stop | Station | Location, arrival: datetime.datetime = None, arrival_delay: int = None,\n arrival_platform: str = None,\n departure: datetime.datetime = None, departure_delay: int = None, departure_platform: str = None):\n def to_dict(self):\n def to_json(self):\n def from_json(json_str):\ndef stopover_from_json(data: dict | str | None):\ndef get_location(place: Location | Station | Stop | Stopover) -> Location | None:\n def __init__(self, amount: float, currency: str):\n def to_dict(self):\n def to_json(self):\n def from_json(json_str):\ndef price_from_json(data: dict | str | None):\n def __init__(self, origin: Stop | Station | Location, destination: Stop | Station | Location,\n departure: datetime.datetime, arrival: datetime.datetime, mode: Mode, sub_mode: str = None,\n departure_delay: int = None,\n departure_platform: str = None,\n arrival_delay: int = None, arrival_platform: str = None, line: Line = None, direction: str = None,\n stopovers: list[Stopover] = None, schedule: Schedule = None, public: bool = True,\n operator: Operator = None,\n price: Price = None, polyline: str = None):\n def to_dict(self):\n def to_json(self):\n def from_json(json_str):\n def get_departure(self, realtime=True):\n def get_arrival(self, realtime=True):\n def duration(self, realtime=True):\ndef leg_from_json(data: dict | str | None):\n def __init__(self, id: str, legs: list[Leg], price: Price = None):\n def to_dict(self):\n def to_json(self):\n def from_json(json_str):\n def get_departure(self, realtime=True):\n def get_arrival(self, realtime=True):\n def duration(self, realtime=True):\n def get_trace(self) -> list[tuple[tuple[float, float], datetime.datetime, Mode, bool]]:\ndef journey_from_json(data: dict | str | None):\ndef from_json(data: dict | str | None):\nclass Location:\nclass Station:\nclass Stop:\nclass Region:\nclass Mode(Enum):\nclass Operator:\nclass Line:\nclass Route:\nclass ScheduleSequenceElement:\nclass Schedule:\nclass Stopover:\nclass Price:\nclass Leg:\nclass Journey:\n TRAIN = 'train'\n BUS = 'bus'\n WATERCRAFT = 'watercraft'\n TAXI = 'taxi'\n GONDOLA = 'gondola'\n AIRCRAFT = 'aircraft'\n CAR = 'car'\n BICYCLE = 'bicycle'\n WALKING = 'walking'\n UNKNOWN = ''" }, { "identifier": "Options", "path": "hiveline/models/options.py", "snippet": "class Options:\n def __init__(self, result):\n self.vc_id = result[\"vc-id\"]\n self.sim_id = result[\"sim-id\"]\n self.created = fptf.read_datetime(result[\"created\"])\n self.meta = result[\"meta\"]\n self.traveller = Traveller(result[\"traveller\"])\n self.options = [Option.from_dict(o) for o in result[\"options\"]]\n\n def get_option(self, option_id: str):\n for o in self.options:\n if o.id == option_id:\n return o\n return None\n\n def to_dict(self):\n return {\n \"vc-id\": self.vc_id,\n \"sim-id\": self.sim_id,\n \"created\": fptf.format_datetime(self.created),\n \"meta\": self.meta,\n \"traveller\": self.traveller.to_dict(),\n \"options\": [o.to_dict() for o in self.options]\n }" }, { "identifier": "Option", "path": "hiveline/models/options.py", "snippet": "class Option:\n def __init__(self, id: str, origin: fptf.Location, destination: fptf.Location, departure: datetime.datetime,\n modes: list[fptf.Mode], journey: fptf.Journey,\n trace: list[tuple[tuple[float, float], datetime.datetime, fptf.Mode, bool]] | None = None):\n self.id = id\n self.origin = origin\n self.destination = destination\n self.departure = departure\n self.modes = modes\n self.journey = journey\n self.trace = trace\n\n def to_dict(self):\n return {\n \"route-option-id\": self.id,\n \"origin\": [self.origin.longitude, self.origin.latitude],\n \"destination\": [self.destination.longitude, self.destination.latitude],\n \"departure\": fptf.format_datetime(self.departure),\n \"modes\": [m.to_string() for m in self.modes],\n \"journey\": self.journey.to_dict()\n }\n\n @staticmethod\n def from_dict(result):\n id = result[\"route-option-id\"]\n origin = fptf.Location(longitude=result[\"origin\"][0], latitude=result[\"origin\"][1])\n destination = fptf.Location(longitude=result[\"destination\"][0], latitude=result[\"destination\"][1])\n departure = fptf.read_datetime(result[\"departure\"])\n modes = [fptf.Mode.from_string(m) for m in result[\"modes\"]]\n journey = fptf.journey_from_json(result[\"journey\"])\n trace = None\n return Option(id, origin, destination, departure, modes, journey, trace)\n\n def has_car(self):\n \"\"\"\n Check if a route option has a car leg\n :return: True if the route option has a car leg, False otherwise\n \"\"\"\n\n for leg in self.journey.legs:\n mode = leg.mode\n\n if mode == fptf.Mode.CAR:\n return True\n\n return False\n\n def get_trace(self) -> list[tuple[tuple[float, float], datetime.datetime, fptf.Mode, bool]]:\n if self.trace is None:\n self.trace = self.journey.get_trace()\n return self.trace" }, { "identifier": "get_database", "path": "hiveline/mongo/db.py", "snippet": "def get_database():\n dotenv.load_dotenv()\n\n user = os.getenv(\"UP_MONGO_USER\")\n password = os.getenv(\"UP_MONGO_PASSWORD\")\n domain = os.getenv(\"UP_MONGO_DOMAIN\")\n database = os.getenv(\"UP_MONGO_DATABASE\")\n\n connection_string = \"mongodb://%s:%s@%s/%s?authSource=admin\" % (user, password, domain, database)\n\n client = MongoClient(connection_string)\n\n return client[database]" }, { "identifier": "ensure_directory", "path": "hiveline/routing/util.py", "snippet": "def ensure_directory(path):\n \"\"\"\n Ensures that the given directory exists. If it does not exist, it will be created.\n :param path: The path to the directory\n :return:\n \"\"\"\n if not os.path.isdir(path):\n pathlib.Path(path).mkdir(parents=True, exist_ok=True)" } ]

[ { "identifier": "DOMAIN", "path": "custom_components/uhppoted/const.py", "snippet": "DOMAIN = 'uhppoted'" }, { "identifier": "CONF_BIND_ADDR", "path": "custom_components/uhppoted/const.py", "snippet": "CONF_BIND_ADDR = 'bind_address'" }, { "identifier": "CONF_BROADCAST_ADDR", "path": "custom_components/uhppoted/const.py", "snippet": "CONF_BROADCAST_ADDR = 'broadcast_address'" }, { "identifier": "CONF_LISTEN_ADDR", "path": "custom_components/uhppoted/const.py", "snippet": "CONF_LISTEN_ADDR = 'listen_address'" }, { "identifier": "CONF_DEBUG", "path": "custom_components/uhppoted/const.py", "snippet": "CONF_DEBUG = 'debug'" }, { "identifier": "ATTR_ADDRESS", "path": "custom_components/uhppoted/const.py", "snippet": "ATTR_ADDRESS = 'address'" }, { "identifier": "ATTR_NETMASK", "path": "custom_components/uhppoted/const.py", "snippet": "ATTR_NETMASK = 'netmask'" }, { "identifier": "ATTR_GATEWAY", "path": "custom_components/uhppoted/const.py", "snippet": "ATTR_GATEWAY = 'gateway'" }, { "identifier": "ATTR_FIRMWARE", "path": "custom_components/uhppoted/const.py", "snippet": "ATTR_FIRMWARE = 'firmware'" }, { "identifier": "configure_controllers", "path": "custom_components/uhppoted/config.py", "snippet": "def configure_controllers(options, f):\n if CONF_CONTROLLERS in options:\n controllers = options[CONF_CONTROLLERS]\n\n for c in controllers:\n controller = f'{c[CONF_CONTROLLER_ID]}'.strip()\n serial_no = f'{c[CONF_CONTROLLER_SERIAL_NUMBER]}'.strip()\n address = f'{c[CONF_CONTROLLER_ADDR]}'.strip()\n\n f(controller, serial_no, address)" }, { "identifier": "configure_doors", "path": "custom_components/uhppoted/config.py", "snippet": "def configure_doors(options, g):\n if CONF_CONTROLLERS in options and CONF_DOORS in options:\n controllers = options[CONF_CONTROLLERS]\n doors = options[CONF_DOORS]\n\n for c in controllers:\n controller = f'{c[CONF_CONTROLLER_ID]}'.strip()\n serial_no = f'{c[CONF_CONTROLLER_SERIAL_NUMBER]}'.strip()\n address = f'{c[CONF_CONTROLLER_ADDR]}'.strip()\n\n for d in doors:\n door = f'{d[CONF_DOOR_ID]}'.strip()\n door_no = f'{d[CONF_DOOR_NUMBER]}'.strip()\n door_controller = f'{d[CONF_DOOR_CONTROLLER]}'.strip()\n\n if door_controller == controller:\n g(controller, serial_no, door, door_no)" }, { "identifier": "ControllerInfo", "path": "custom_components/uhppoted/controller.py", "snippet": "class ControllerInfo(SensorEntity):\n _attr_icon = 'mdi:identifier'\n _attr_has_entity_name: True\n _attr_translation_key = 'controller_id'\n\n def __init__(self, u, controller, serial_no):\n super().__init__()\n\n _LOGGER.debug(f'controller {controller} {serial_no}')\n\n self.uhppote = u\n self.controller = controller\n self.serial_no = int(f'{serial_no}')\n self._name = f'uhppoted.controller.{controller}.info'.lower()\n self._state = None\n self._attributes: Dict[str, Any] = {\n ATTR_ADDRESS: '',\n ATTR_NETMASK: '',\n ATTR_GATEWAY: '',\n ATTR_FIRMWARE: '',\n }\n self._available = False\n\n @property\n def unique_id(self) -> str:\n return f'uhppoted.controller.{self.controller}.info'.lower()\n\n @property\n def name(self) -> str:\n return self._name\n\n @property\n def available(self) -> bool:\n return self._available\n\n @property\n def state(self) -> Optional[str]:\n if self._state != None:\n return f'{self._state}'\n\n return None\n\n @property\n def extra_state_attributes(self) -> Dict[str, Any]:\n return self._attributes\n\n async def async_update(self):\n _LOGGER.debug(f'controller:{self.controller} update info')\n try:\n response = self.uhppote.get_controller(self.serial_no)\n\n if response.controller == self.serial_no:\n self._state = response.controller\n self._available = True\n self._attributes[ATTR_ADDRESS] = f'{response.ip_address}'\n self._attributes[ATTR_NETMASK] = f'{response.subnet_mask}'\n self._attributes[ATTR_GATEWAY] = f'{response.gateway}'\n self._attributes[ATTR_FIRMWARE] = f'{response.version} {response.date:%Y-%m-%d}'\n\n except (Exception):\n self._available = False\n _LOGGER.exception(f'error retrieving controller {self.controller} information')" }, { "identifier": "ControllerDoorOpened", "path": "custom_components/uhppoted/door.py", "snippet": "class ControllerDoorOpened(EventEntity):\n _attr_icon = 'mdi:door'\n _attr_has_entity_name: True\n _attr_event_types = ['OPEN', 'CLOSE']\n\n def __init__(self, u, controller, serial_no, door, door_id):\n super().__init__()\n\n _LOGGER.debug(f'controller {controller}: door:{door} open event')\n\n self.uhppote = u\n self.controller = controller\n self.serial_no = int(f'{serial_no}')\n self.door = door\n self.door_id = int(f'{door_id}')\n\n self._name = f'uhppoted.door.{door}.open.event'.lower()\n self._open = None\n\n @property\n def unique_id(self) -> str:\n return f'uhppoted.door.{self.door}.open.event'.lower()\n\n @property\n def name(self) -> str:\n return self._name\n\n async def async_update(self):\n _LOGGER.debug(f'controller:{self.controller} update door {self.door}.open.event state')\n try:\n response = self.uhppote.get_status(self.serial_no)\n last = self._open\n\n if response.controller == self.serial_no:\n if self.door_id == 1:\n self._open = response.door_1_open == True\n elif self.door_id == 2:\n self._open = response.door_2_open == True\n elif self.door_id == 3:\n self._open = response.door_3_open == True\n elif self.door_id == 4:\n self._open = response.door_4_open == True\n else:\n self._open = None\n\n if self._open != last and self._open:\n self._trigger_event('OPEN')\n elif self._open != last and not self._open:\n self._trigger_event('CLOSE')\n\n except (Exception):\n self._available = False\n _LOGGER.exception(f'error retrieving controller {self.controller} status')" } ]

[ { "identifier": "env_sac", "path": "sacd/env_sac.py", "snippet": "class Env():\r\n def __init__(self, observation_data, I, max_item_id, each_user, K, item_ctr_dict, pop_dict):\r\n def reset(self, observation):\r\n def step(self, action, pass_item_list):\r" }, { "identifier": "SacdAgent", "path": "sacd/agent/sacd.py", "snippet": "class SacdAgent(BaseAgent):\n def __init__(self, env, log_dir, num_steps=100000, batch_size=64,\n lr=0.0003, memory_size=1000000, gamma=0.99, multi_step=1,\n target_entropy_ratio=0.98, start_steps=20000,\n update_interval=4, target_update_interval=8000,\n use_per=False, dueling_net=False, num_eval_steps=125000,\n max_episode_steps=27000, log_interval=10, eval_interval=1000,\n cuda=False, state_re=True, seed=0, K=10):\n super().__init__(\n env, log_dir, num_steps, batch_size, memory_size, gamma,\n multi_step, target_entropy_ratio, start_steps, update_interval,\n target_update_interval, use_per, num_eval_steps, max_episode_steps,\n log_interval, eval_interval, cuda, state_re, seed, K)\n\n self.actor = PolicyNetwork(self.env.n_observation, self.env.n_actions, self.env, self.batch_size,\n state_representation=state_re).to(self.device)\n self.main_critic = TwinnedQNetwork(self.env.n_observation, self.env.n_actions, self.batch_size,\n state_representation=state_re, dueling_net=dueling_net).to(\n device=self.device)\n self.target_critic = TwinnedQNetwork(self.env.n_observation, self.env.n_actions, self.batch_size,\n state_representation=state_re, dueling_net=dueling_net).to(\n device=self.device).eval()\n self.target_critic.load_state_dict(self.main_critic.state_dict())\n disable_gradients(self.target_critic)\n self.policy_optim = Adam(self.actor.parameters(), lr=lr)\n self.q1_optim = Adam(self.main_critic.Q1.parameters(), lr=lr)\n self.q2_optim = Adam(self.main_critic.Q2.parameters(), lr=lr)\n self.avg_prob = 1.0 / self.env.n_actions\n self.maximum_entropy = -np.log(self.avg_prob) * target_entropy_ratio\n self.log_alpha = torch.zeros(1, requires_grad=True, device=self.device)\n self.alpha = self.log_alpha.exp()\n self.alpha_optim = Adam([self.log_alpha], lr=lr)\n\n # 探索 随机动作\n def explore(self, state):\n state = np.array([int(i) for i in state[0].split('|')])\n state = torch.from_numpy(state).to(self.device)\n with torch.no_grad():\n action, _, _ = self.actor.sample(state)\n return action.item()\n\n def exploit(self, state, user_id):\n s = self.env.reset(np.array([int(i) for i in state.split('|')]))\n s = torch.from_numpy(s).to(self.device)\n with torch.no_grad():\n action = self.actor.act(s, user_id)\n return action\n\n def update_target_critic(self):\n self.target_critic.load_state_dict(self.main_critic.state_dict())\n\n def calc_current_q(self, states, actions, rewards, next_states, dones):\n curr_q1, curr_q2 = self.main_critic(states)\n curr_q1 = curr_q1.gather(1, actions.long() - 1)\n curr_q2 = curr_q2.gather(1, actions.long() - 1)\n return curr_q1, curr_q2\n\n def calc_target_q(self, states, actions, rewards, next_states, dones):\n with torch.no_grad():\n _, action_probs, log_action_probs = self.actor.sample(next_states)\n next_q1, next_q2 = self.target_critic(next_states)\n next_q = torch.min(next_q1, next_q2)\n next_v = (action_probs * (next_q - self.alpha * log_action_probs)).sum(dim=1, keepdim=True)\n return rewards + self.gamma_n * next_v\n\n def calc_critic_loss(self, batch):\n target_q = self.calc_target_q(*batch)\n curr_q1, curr_q2 = self.calc_current_q(*batch)\n errors = torch.abs(curr_q1.detach() - target_q)\n\n mean_q1 = curr_q1.detach().mean().item()\n mean_q2 = curr_q2.detach().mean().item()\n\n q1_loss = torch.mean((curr_q1 - target_q).pow(2))\n q2_loss = torch.mean((curr_q2 - target_q).pow(2))\n\n update_params(self.q1_optim, q1_loss)\n update_params(self.q2_optim, q2_loss)\n\n return q1_loss, q2_loss, errors, mean_q1, mean_q2\n\n def calc_policy_loss(self, batch):\n states, actions, rewards, next_states, dones = batch\n _, action_probs, log_action_probs = self.actor.sample(states)\n with torch.no_grad():\n q1, q2 = self.main_critic(states)\n q = torch.min(q1, q2)\n\n entropies = -torch.sum(action_probs * log_action_probs, dim=1, keepdim=True)\n q = torch.sum(action_probs * q, dim=1, keepdim=True)\n policy_loss = -(self.alpha * entropies + q).mean()\n update_params(self.policy_optim, policy_loss)\n\n return policy_loss, entropies.detach()\n\n def calc_entropy_loss(self, entropies):\n assert not entropies.requires_grad\n entropy_loss = torch.mean(self.log_alpha * (self.maximum_entropy - entropies))\n update_params(self.alpha_optim, entropy_loss)\n self.alpha = self.log_alpha.exp()\n return self.alpha\n\n def save_models(self, save_dir):\n super().save_models(save_dir)\n self.actor.save(os.path.join(save_dir, 'policy.pth'))\n self.main_critic.save(os.path.join(save_dir, 'online_critic.pth'))\n self.target_critic.save(os.path.join(save_dir, 'target_critic.pth'))" }, { "identifier": "rowdata_process_util", "path": "util/rowdata_process_util.py", "snippet": "class Dataset():\r\n def __init__(self, data_path, split=\"::\"):\r\n def loadData(self, dataset_path, split=\"::\"):\r\n def splitData(self):\r\n def getAllItem(self):\r\n def getPopular(self, data_dict_train):\r" }, { "identifier": "json_util", "path": "util/json_util.py", "snippet": "class JsonEncoder(json.JSONEncoder):\r\n def default(self, obj):\r\ndef save_dict(filename, dic):\r\ndef load_dict(filename):\r" }, { "identifier": "Gini", "path": "util/metric/Gini.py", "snippet": "def Gini(p_dic):\r\n p_list = list(p_dic.values())\r\n cum = np.cumsum(sorted(np.append(p_list, 0)))\r\n sum = cum[-1]\r\n x = np.array(range(len(cum))) / len(p_list)\r\n y = cum / sum\r\n B = np.trapz(y, x=x)\r\n A = 0.5 - B\r\n G = A / (A + B)\r\n return G\r" }, { "identifier": "HR", "path": "util/metric/HR.py", "snippet": "def HR(test_set, rec_list):\r\n if list(set(test_set) & set(rec_list)):\r\n return 1\r\n else:\r\n return 0\r" }, { "identifier": "ndcg_metric", "path": "util/metric/NDCG.py", "snippet": "def ndcg_metric(topN_dict, test_dict):\r\n ndcg = 0\r\n for key, topn_set in topN_dict.items():\r\n test_set = test_dict.get(key)\r\n dsct_list = [1 / np.log2(i + 1) for i in range(1, len(topn_set) + 1)]\r\n z_k = sum(dsct_list)\r\n if test_set is not None:\r\n mask = [0 if i not in test_set else 1 for i in topn_set]\r\n ndcg += sum(np.multiply(dsct_list, mask)) / z_k\r\n ndcg = ndcg / len(topN_dict.items())\r\n return ndcg\r" } ]

[ { "identifier": "PoeBot", "path": "fireworks_poe_bot/fastapi_poe/base.py", "snippet": "class PoeBot:\n # Override these for your bot\n\n async def get_response(\n self, query: QueryRequest\n ) -> AsyncIterable[Union[PartialResponse, ServerSentEvent]]:\n \"\"\"Override this to return a response to user queries.\"\"\"\n yield self.text_event(\"hello\")\n\n async def get_settings(self, setting: SettingsRequest) -> SettingsResponse:\n \"\"\"Override this to return non-standard settings.\"\"\"\n return SettingsResponse()\n\n async def on_feedback(self, feedback_request: ReportFeedbackRequest) -> None:\n \"\"\"Override this to record feedback from the user.\"\"\"\n pass\n\n async def on_error(self, error_request: ReportErrorRequest) -> None:\n \"\"\"Override this to record errors from the Poe server.\"\"\"\n logger.error(f\"Error from Poe server: {error_request}\")\n\n # Helpers for generating responses\n @staticmethod\n def text_event(text: str) -> ServerSentEvent:\n return ServerSentEvent(data=json.dumps({\"text\": text}), event=\"text\")\n\n @staticmethod\n def replace_response_event(text: str) -> ServerSentEvent:\n return ServerSentEvent(\n data=json.dumps({\"text\": text}), event=\"replace_response\"\n )\n\n @staticmethod\n def done_event() -> ServerSentEvent:\n return ServerSentEvent(data=\"{}\", event=\"done\")\n\n @staticmethod\n def suggested_reply_event(text: str) -> ServerSentEvent:\n return ServerSentEvent(data=json.dumps({\"text\": text}), event=\"suggested_reply\")\n\n @staticmethod\n def meta_event(\n *,\n content_type: ContentType = \"text/markdown\",\n refetch_settings: bool = False,\n linkify: bool = True,\n suggested_replies: bool = True,\n ) -> ServerSentEvent:\n return ServerSentEvent(\n data=json.dumps(\n {\n \"content_type\": content_type,\n \"refetch_settings\": refetch_settings,\n \"linkify\": linkify,\n \"suggested_replies\": suggested_replies,\n }\n ),\n event=\"meta\",\n )\n\n @staticmethod\n def error_event(\n text: Optional[str] = None, *, allow_retry: bool = True\n ) -> ServerSentEvent:\n data: Dict[str, Union[bool, str]] = {\"allow_retry\": allow_retry}\n if text is not None:\n data[\"text\"] = text\n return ServerSentEvent(data=json.dumps(data), event=\"error\")\n\n # Internal handlers\n\n async def handle_report_feedback(\n self, feedback_request: ReportFeedbackRequest\n ) -> JSONResponse:\n await self.on_feedback(feedback_request)\n return JSONResponse({})\n\n async def handle_report_error(\n self, error_request: ReportErrorRequest\n ) -> JSONResponse:\n await self.on_error(error_request)\n return JSONResponse({})\n\n async def handle_settings(self, settings_request: SettingsRequest) -> JSONResponse:\n settings = await self.get_settings(settings_request)\n return JSONResponse(settings.dict())\n\n async def handle_query(self, query: QueryRequest) -> AsyncIterable[ServerSentEvent]:\n try:\n async for event in self.get_response(query):\n if isinstance(event, ServerSentEvent):\n yield event\n elif isinstance(event, ErrorResponse):\n yield self.error_event(event.text, allow_retry=event.allow_retry)\n elif isinstance(event, MetaResponse):\n yield self.meta_event(\n content_type=event.content_type,\n refetch_settings=event.refetch_settings,\n linkify=event.linkify,\n suggested_replies=event.suggested_replies,\n )\n elif event.is_suggested_reply:\n yield self.suggested_reply_event(event.text)\n elif event.is_replace_response:\n yield self.replace_response_event(event.text)\n else:\n yield self.text_event(event.text)\n except Exception as e:\n logger.exception(\"Error responding to query\")\n yield self.error_event(repr(e), allow_retry=False)\n yield self.done_event()" }, { "identifier": "PartialResponse", "path": "fireworks_poe_bot/fastapi_poe/types.py", "snippet": "class PartialResponse(BaseModel):\n \"\"\"Representation of a (possibly partial) response from a bot.\"\"\"\n\n text: str\n \"\"\"Partial response text.\n\n If the final bot response is \"ABC\", you may see a sequence\n of PartialResponse objects like PartialResponse(text=\"A\"),\n PartialResponse(text=\"B\"), PartialResponse(text=\"C\").\n\n \"\"\"\n\n raw_response: object = None\n \"\"\"For debugging, the raw response from the bot.\"\"\"\n\n full_prompt: Optional[str] = None\n \"\"\"For debugging, contains the full prompt as sent to the bot.\"\"\"\n\n request_id: Optional[str] = None\n \"\"\"May be set to an internal identifier for the request.\"\"\"\n\n is_suggested_reply: bool = False\n \"\"\"If true, this is a suggested reply.\"\"\"\n\n is_replace_response: bool = False\n \"\"\"If true, this text should completely replace the previous bot text.\"\"\"" }, { "identifier": "QueryRequest", "path": "fireworks_poe_bot/fastapi_poe/types.py", "snippet": "class QueryRequest(BaseRequest):\n \"\"\"Request parameters for a query request.\"\"\"\n\n query: List[ProtocolMessage]\n user_id: Identifier\n conversation_id: Identifier\n message_id: Identifier\n metadata: Identifier = \"\"\n api_key: str = \"<missing>\"\n access_key: str = \"<missing>\"\n temperature: float = 0.7\n skip_system_prompt: bool = False\n logit_bias: Dict[str, float] = {}\n stop_sequences: List[str] = []" }, { "identifier": "ReportErrorRequest", "path": "fireworks_poe_bot/fastapi_poe/types.py", "snippet": "class ReportErrorRequest(BaseRequest):\n \"\"\"Request parameters for a report_error request.\"\"\"\n\n message: str\n metadata: Dict[str, Any]" }, { "identifier": "ReportFeedbackRequest", "path": "fireworks_poe_bot/fastapi_poe/types.py", "snippet": "class ReportFeedbackRequest(BaseRequest):\n \"\"\"Request parameters for a report_feedback request.\"\"\"\n\n message_id: Identifier\n user_id: Identifier\n conversation_id: Identifier\n feedback_type: FeedbackType" }, { "identifier": "SettingsRequest", "path": "fireworks_poe_bot/fastapi_poe/types.py", "snippet": "class SettingsRequest(BaseRequest):\n \"\"\"Request parameters for a settings request.\"\"\"" }, { "identifier": "SettingsResponse", "path": "fireworks_poe_bot/fastapi_poe/types.py", "snippet": "class SettingsResponse(BaseModel):\n context_clear_window_secs: Optional[int] = None # deprecated\n allow_user_context_clear: bool = True # deprecated\n server_bot_dependencies: Dict[str, int] = Field(default_factory=dict)\n allow_attachments: bool = False\n introduction_message: str = \"\"" }, { "identifier": "ErrorResponse", "path": "fireworks_poe_bot/fastapi_poe/types.py", "snippet": "class ErrorResponse(PartialResponse):\n \"\"\"Communicate errors from server bots.\"\"\"\n\n allow_retry: bool = False" }, { "identifier": "log_error", "path": "fireworks_poe_bot/plugin.py", "snippet": "@abstractmethod\ndef log_error(self, payload: Dict[str, Any]):\n ..." }, { "identifier": "log_info", "path": "fireworks_poe_bot/plugin.py", "snippet": "@abstractmethod\ndef log_info(self, payload: Dict[str, Any]):\n ..." }, { "identifier": "log_warn", "path": "fireworks_poe_bot/plugin.py", "snippet": "@abstractmethod\ndef log_warn(self, payload: Dict[str, Any]):\n ..." }, { "identifier": "register_bot_plugin", "path": "fireworks_poe_bot/plugin.py", "snippet": "def register_bot_plugin(config_key: str, BotConfigClass: type = ModelConfig):\n def decorator(BotPluginClass: type):\n BOT_PLUGINS.append(_BotPlugin(\n BotPluginClass=BotPluginClass,\n BotConfigClass=BotConfigClass,\n config_key=config_key,\n ))\n\n return decorator" }, { "identifier": "ModelConfig", "path": "fireworks_poe_bot/config.py", "snippet": "class ModelConfig(BaseModel):\n model: str\n api_key: str\n\n SERVER_endpoint_account_override: Optional[str] = None\n SERVER_endpoint_model_override: Optional[str] = None\n\n @property\n def model_fqn(self):\n if (\n self.SERVER_endpoint_account_override is not None\n or self.SERVER_endpoint_model_override is not None\n ):\n _, account, _, model = self.model.split(\"/\")\n account = self.SERVER_endpoint_account_override or account\n model = self.SERVER_endpoint_model_override or model\n return f\"accounts/{account}/models/{model}\"\n else:\n return self.model" } ]

[ { "identifier": "path_stats", "path": "q_table.py", "snippet": "class path_stats():\n def __init__(self, path_queues, path_weights=0):\n self.path_queues = path_queues\n self.path_weights = path_weights\n self.action = 2\n self.reward = 0\n\n def weighted_average(self):\n queue_difference = abs(self.path_queues[0]-self.path_queues[1])\n weight_avg_queue = sum([self.path_queues[i] * self.path_weights[i] for i in range(len(self.path_weights))]) / sum(self.path_weights)\n return (-queue_difference + 50) + weight_avg_queue\n\n def get_next_action(self, table, epsilon):\n if np.random.random() < epsilon:\n self.action = np.random.choice(np.arange(3))\n else:\n # print(q_table[:, math.ceil(paths.path_queues[0] / 10), math.ceil(paths.path_queues[1] / 10)])\n self.action = np.argmax(table.q_table[:, math.ceil(min(10, self.path_queues[0] / 10)), math.ceil(min(10, self.path_queues[1] / 10))])\n\n def get_new_weights(self, old_paths, action_weight):\n if self.action == 2:\n self.path_weights = old_paths.path_weights\n elif self.action == 0:\n weights = [old_paths.path_weights[0] + action_weight, old_paths.path_weights[1] - action_weight]\n weights = [max(0, min(num, 100)) for num in weights]\n self.path_weights = weights\n elif self.action == 1:\n weights = [old_paths.path_weights[0] - action_weight, old_paths.path_weights[1] + action_weight]\n weights = [max(0, min(num, 100)) for num in weights]\n self.path_weights = weights\n\n def get_reward(self, old_paths):\n # Calculate reward\n old_average = old_paths.weighted_average()\n new_average = self.weighted_average()\n if new_average < old_average - 0.5:\n self.reward = 1\n elif new_average > old_average + 0.5:\n self.reward = -1\n else:\n self.reward = 0\n # print(old_average, new_average, new_paths.reward)\n\n def change_path_weights(self, old_paths, p4info_helper, ingress_sw, nhop_dmacs, nhop_ipv4s, ports):\n if self.path_weights[0] > old_paths.path_weights[0]:\n for i in range(old_paths.path_weights[0], self.path_weights[0]):\n update_path_weights(p4info_helper, ingress_sw=ingress_sw, value=i,\n nhop_dmac=nhop_dmacs[0], nhop_ipv4=nhop_ipv4s[0], port=ports[0])\n elif self.path_weights[0] < old_paths.path_weights[0]:\n for i in range(self.path_weights[0], old_paths.path_weights[0]):\n update_path_weights(p4info_helper, ingress_sw=ingress_sw, value=i,\n nhop_dmac=nhop_dmacs[1], nhop_ipv4=nhop_ipv4s[1], port=ports[1])" }, { "identifier": "q_table", "path": "q_table.py", "snippet": "class q_table():\n def __init__(self):\n self.q_table = self.init_q_table()\n self.parameters = {'LEARNING_RATE': 0.2,\n 'DISCOUNT': 0.1,\n 'epsilon': 0.4,\n 'action_weight': 5,\n 'pkt_counter': 0}\n\n def init_q_table(self):\n actions = ('updown', 'downup', 'no_change')\n q_table = np.random.rand(len(actions), 11, 11) * 0.1 - 0.05\n q_table = np.round(q_table, decimals=3)\n return q_table\n\n def update_q_table(self, LEARNING_RATE, DISCOUNT, old_paths, new_paths):\n # Calculate new Q-value\n indices = [old_paths.action, math.ceil(min(10, old_paths.path_queues[0] / 10)), math.ceil(min(10, old_paths.path_queues[1] / 10))]\n max_future_q = np.argmax(self.q_table[:, indices[1], indices[2]])\n current_q = self.q_table[indices[0], indices[1], indices[2]]\n new_q = (1 - LEARNING_RATE)* current_q + LEARNING_RATE * (old_paths.reward + DISCOUNT * max_future_q)\n new_q = np.round(max(-1, min(new_q, 1)), decimals=3)\n self.q_table[indices[0], indices[1], indices[2]] = new_q\n # print(current_q, new_q)\n\n def update_parameters(self):\n self.parameters['pkt_counter'] += 1\n if self.parameters['pkt_counter'] % 80 == 0:\n if self.parameters['epsilon'] > 0.1:\n self.parameters['epsilon'] = np.round(self.parameters['epsilon'] - 0.1, decimals=1) # [0.4, 0.3, 0.2, 0.1]\n if self.parameters['LEARNING_RATE'] > 0.05:\n self.parameters['LEARNING_RATE'] *= 0.85\n if self.parameters['action_weight'] > 1:\n self.parameters['action_weight'] = math.ceil(self.parameters['action_weight'] * 0.5) # [5, 3, 2, 1]\n print(self.parameters)\n\n def reset_parameters(self, path, reset_params):\n reset_params.append(path.path_queues)\n if len(reset_params) == 10:\n if (all(lst[0] > 98 for lst in reset_params) and all(lst[1] < 2 for lst in reset_params)) or (all(lst[1] > 98 for lst in reset_params) and all(lst[0] < 2 for lst in reset_params)):\n self.parameters['LEARNING_RATE'] = 0.1\n self.parameters['epsilon'] = 0.2\n self.parameters['action_weight'] = 5\n self.parameters['pkt_counter'] = 0\n print('PARAMETERS HAVE BEEN RESET!!!')\n reset_params.clear()\n if len(reset_params) == 10:\n reset_params.pop(0)" } ]

[ { "identifier": "ProxDataset_txt", "path": "posa/dataset.py", "snippet": "class ProxDataset_txt(Dataset): # when jump_step=8, for a whole seq, dataset's max_frame is 165, max num_seg is 29\n def __init__(self, data_dir, fix_orientation=False, no_obj_classes=8, max_frame=220,\n ds_weights_path=\"posa/support_files/downsampled_weights.npy\", jump_step=8, step_multiplier=1, max_objs=8, pnt_size=1024, \n objs_data_dir='data/protext/objs', max_cats=13, **kwargs):\n '''\n data_dir: directory that stores processed PROXD dataset.\n fix_orientation: flag that specifies whether we always make the first pose in a motion sequence facing\n towards a canonical direction.\n no_obj_classes: number of contact object classes.\n max_frame: the maximum motion sequence length which the model accepts (after applying frame skipping).\n ds_weights_path: the saved downsampling matrix for downsampling body vertices.\n jump_step: for every jump_step frames, we only select the first frame for some sequence.\n step_multiplier: a dummy parameter used to control the number of examples seen in each epoch (You can\n ignore it if you don't know how to adjust it).\n '''\n self.data_dir = data_dir\n self.max_objs = max_objs\n self.pnt_size = pnt_size\n self.max_cats = max_cats\n \n # Setup handle case for dataset: 0 for training, 1 for testing\n is_train = self.data_dir.split('_')[1]\n self.handle = 0 if is_train == 'train' else 1\n self.objs_dir = objs_data_dir\n self.context_dir = os.path.join(data_dir, \"context\")\n self.reduced_verts_dir = os.path.join(data_dir, \"reduced_vertices\")\n self.seq_names = [f.split('.txt')[0] for f in os.listdir(self.context_dir)]\n\n # Setup reading object files and cases\n self._setup_static_objs()\n\n # Initialize for human sequences\n self.reduced_verts_dict = dict()\n self.context_dict = dict()\n\n self.total_frames = 0\n for seq_name in self.seq_names:\n self.reduced_verts_dict[seq_name] = torch.tensor(np.load(os.path.join(self.reduced_verts_dir, seq_name + \".npy\")), dtype=torch.float32)\n with open(os.path.join(self.context_dir, seq_name + \".txt\")) as f:\n text_prompt, given_objs, target_obj = f.readlines()\n text_prompt = text_prompt.strip('\\n')\n given_objs = given_objs.strip('\\n').split(' ')\n self.context_dict[seq_name] = (text_prompt, given_objs, target_obj)\n\n self.fix_orientation = fix_orientation\n self.no_obj_classes = no_obj_classes\n self.ds_weights_path = ds_weights_path\n self.ds_weights = None\n self.associated_joints = None\n if fix_orientation:\n self.ds_weights = torch.tensor(np.load(self.ds_weights_path))\n self.associated_joints = torch.argmax(self.ds_weights, dim=1)\n\n self.jump_step = jump_step\n self.step_multiplier = step_multiplier\n\n @property\n def _cat(self):\n return {\n \"chair\": 1,\n \"table\": 2,\n \"cabinet\": 3,\n \"sofa\": 4,\n \"bed\": 5,\n \"chest_of_drawers\": 6,\n \"chest\": 6,\n \"stool\": 7,\n \"tv_monitor\": 8,\n \"tv\": 8,\n \"lighting\": 9,\n \"shelving\": 10,\n \"seating\": 11,\n \"furniture\": 12,\n \"human\": 0,\n }\n\n def _setup_static_objs(self):\n self.scenes = os.listdir(self.objs_dir)\n self.objs = dict()\n self.cats = dict()\n for scene in self.scenes:\n self.objs[scene] = dict()\n self.cats[scene] = dict()\n \n objs_list = os.listdir(os.path.join(self.objs_dir, scene))\n for obj_file in objs_list:\n obj = obj_file[:-4]\n cat = obj.split('.')[0].split('_')[0]\n # Read vertices of objects\n with open(os.path.join(self.objs_dir, scene, obj_file), 'rb') as f:\n verts = np.load(f)\n self.objs[scene][obj] = verts\n self.cats[scene][obj] = self._cat[cat]\n \n def __len__(self):\n return len(self.seq_names)\n\n def __getitem__(self, idx):\n # seq_idx = torch.randint(len(self.seq_names), size=(1,))\n seq_idx = idx\n seq_name = self.seq_names[seq_idx]\n scene = seq_name.split('_')[0]\n all_objs = self.objs[scene]\n all_cats = self.cats[scene]\n text_prompt, given_objs, target_obj = self.context_dict[seq_name]\n human_verts = self.reduced_verts_dict[seq_name]\n\n # Initialize for objects, note that, the first object is human\n obj_verts = torch.zeros(self.max_objs+1, self.pnt_size, 3)\n obj_verts[0] = human_verts.clone().detach()\n obj_mask = torch.zeros(self.max_objs+1)\n obj_cats = torch.zeros(self.max_objs+1, self.max_cats)\n obj_cats[0][self._cat['human']] = 1\n for idx, obj in enumerate(given_objs):\n cat = obj.split('_')[0]\n obj_verts[idx+1] = torch.tensor(all_objs[obj])\n obj_mask[idx+1] = 1\n obj_cats[idx+1][self._cat[cat]] = 1\n\n # Retrieve information of target vertices\n target_verts = all_objs[target_obj]\n target_cat = target_obj.split('_')[0]\n target_num = self._cat[target_cat]\n target_cat = torch.zeros(self.max_cats)\n target_cat[target_num] = 1\n\n return obj_mask, obj_verts, obj_cats, target_verts, target_cat, text_prompt" }, { "identifier": "create_model_and_diffusion", "path": "util/model_util.py", "snippet": "def create_model_and_diffusion(datatype):\n # model = SceneDiffusionModel(**get_model_args(args, data))\n if datatype == \"proxd\":\n model = SceneDiffusionModel(**get_default_model_proxd())\n else:\n model = SceneDiffusionModel(**get_default_model_humanise())\n diffusion = create_gaussian_diffusion(get_default_diffusion())\n return model, diffusion" } ]

[ { "identifier": "molecular_graph_featurizer", "path": "active_learning/utils.py", "snippet": "def molecular_graph_featurizer(smiles: str, y=None, structural_feats: bool = True, functional_feats: bool = True):\n\n y = torch.tensor([y]).to(torch.long)\n\n mol = Chem.MolFromSmiles(smiles, sanitize=True)\n Chem.AssignStereochemistry(mol, cleanIt=True, force=True)\n\n # RDKIT Atom featurization\n x = atom_featurizer(mol, structural_feats, functional_feats)\n\n # Edge featurization\n edge_indices, edge_attrs = [], []\n for bond in mol.GetBonds():\n i = bond.GetBeginAtomIdx()\n j = bond.GetEndAtomIdx()\n\n edge_indices += [[i, j], [j, i]]\n\n edge_index = torch.tensor(edge_indices)\n edge_index = edge_index.t().to(torch.long).view(2, -1)\n\n # Sort indices.\n if edge_index.numel() > 0:\n perm = (edge_index[0] * x.size(0) + edge_index[1]).argsort()\n edge_index = edge_index[:, perm]\n\n if torch.isnan(x).any():\n return smiles\n # raise ValueError(f\"Featurizing {smiles} gave nan(s)\")\n\n graph = Data(x=x, edge_index=edge_index, smiles=smiles, y=y)\n\n return graph" }, { "identifier": "smiles_to_ecfp", "path": "active_learning/utils.py", "snippet": "def smiles_to_ecfp(smiles: list[str], radius: int = 2, nbits: int = 1024, silent: bool = True, to_array: bool = True) \\\n -> np.ndarray:\n \"\"\" Get a Numpy array of ECFPs from a list of SMILES strings \"\"\"\n from rdkit.Chem.AllChem import GetMorganFingerprintAsBitVect\n from rdkit.Chem import MolFromSmiles\n from rdkit.DataStructs import ConvertToNumpyArray\n\n if type(smiles) is str:\n smiles = [smiles]\n\n fp = [GetMorganFingerprintAsBitVect(MolFromSmiles(s), radius, nBits=nbits) for s in tqdm(smiles, disable=silent)]\n\n if not to_array:\n return fp\n\n output = []\n for f in fp:\n arr = np.zeros((1,))\n ConvertToNumpyArray(f, arr)\n output.append(arr)\n\n return np.asarray(output)" }, { "identifier": "get_tanimoto_matrix", "path": "active_learning/utils.py", "snippet": "def get_tanimoto_matrix(smiles: list[str], radius: int = 2, nBits: int = 1024, verbose: bool = True,\n scaffolds: bool = False, zero_diag: bool = True, as_vector: bool = False):\n \"\"\" Calculates a matrix of Tanimoto similarity scores for a list of SMILES string\"\"\"\n from active_learning.data_prep import smi_to_scaff\n\n # Make a fingerprint database\n db_fp = {}\n for smi in smiles:\n if scaffolds:\n m = Chem.MolFromSmiles(smi_to_scaff(smi, includeChirality=False))\n else:\n m = Chem.MolFromSmiles(smi)\n fp = AllChem.GetMorganFingerprintAsBitVect(m, radius=radius, nBits=nBits)\n db_fp[smi] = fp\n\n smi_len = len(smiles)\n m = np.zeros([smi_len, smi_len], dtype=np.float16) # We use 16-bit floats to prevent giant matrices\n # Calculate upper triangle of matrix\n for i in tqdm(range(smi_len), disable=not verbose):\n for j in range(i, smi_len):\n m[i, j] = DataStructs.TanimotoSimilarity(db_fp[smiles[i]], db_fp[smiles[j]])\n # Fill in the lower triangle without having to loop (saves ~50% of time)\n m = m + m.T - np.diag(np.diag(m))\n # Fill the diagonal with 0's\n if zero_diag:\n np.fill_diagonal(m, 0)\n if as_vector:\n from scipy.spatial.distance import squareform\n m = squareform(m)\n\n return m" }, { "identifier": "check_featurizability", "path": "active_learning/utils.py", "snippet": "def check_featurizability(smiles: str):\n try:\n mol = Chem.MolFromSmiles(smiles, sanitize=True)\n Chem.AssignStereochemistry(mol, cleanIt=True, force=True)\n\n for atom in mol.GetAtoms():\n try:\n x_ = atom_props(atom)\n except:\n return False\n except:\n return False\n\n return True" }, { "identifier": "ROOT_DIR", "path": "config.py", "snippet": "ROOT_DIR = os.path.realpath(os.path.dirname(__file__))" } ]

[ { "identifier": "SAID_UNet1D", "path": "said/model/diffusion.py", "snippet": "class SAID_UNet1D(SAID):\n \"\"\"SAiD model implemented using U-Net 1D model\"\"\"\n\n def __init__(\n self,\n audio_config: Optional[Wav2Vec2Config] = None,\n audio_processor: Optional[Wav2Vec2Processor] = None,\n noise_scheduler: Type[SchedulerMixin] = DDIMScheduler,\n in_channels: int = 32,\n feature_dim: int = -1,\n diffusion_steps: int = 1000,\n latent_scale: float = 1,\n prediction_type: str = \"epsilon\",\n ):\n \"\"\"Constructor of SAID_UNet1D\n\n Parameters\n ----------\n audio_config : Optional[Wav2Vec2Config], optional\n Wav2Vec2Config object, by default None\n audio_processor : Optional[Wav2Vec2Processor], optional\n Wav2Vec2Processor object, by default None\n noise_scheduler: Type[SchedulerMixin]\n Noise scheduler, by default DDIMScheduler\n in_channels : int\n Dimension of the input, by default 32\n feature_dim : int\n Dimension of the latent feature, by default -1\n diffusion_steps : int\n The number of diffusion steps, by default 1000\n latent_scale : float\n Scaling the latent, by default 1\n prediction_type: str\n Prediction type of the scheduler function, \"epsilon\", \"sample\", or \"v_prediction\", by default \"epsilon\"\n \"\"\"\n super().__init__(\n audio_config=audio_config,\n audio_processor=audio_processor,\n in_channels=in_channels,\n feature_dim=feature_dim,\n diffusion_steps=diffusion_steps,\n latent_scale=latent_scale,\n prediction_type=prediction_type,\n )\n\n # Denoiser\n self.denoiser = UNet1DConditionModel(\n in_channels=in_channels,\n out_channels=in_channels,\n cross_attention_dim=self.feature_dim\n if self.feature_dim > 0\n else self.audio_config.hidden_size,\n )" }, { "identifier": "fit_audio_unet", "path": "said/util/audio.py", "snippet": "def fit_audio_unet(\n waveform: torch.FloatTensor, sampling_rate: int, fps: int, divisor_unet: int\n) -> FittedWaveform:\n \"\"\"Fit the intput audio waveform into UNet1D\n\n Parameters\n ----------\n waveform : torch.FloatTensor\n (T_a), Mono waveform\n sampling_rate : int\n Sampling rate of the audio model\n fps : int\n The number of frames per second\n divisor_unet : int\n Length of the blendshape coefficients sequence should be divided by this number\n\n Returns\n -------\n FittedWaveform\n Fitted waveform with the window\n \"\"\"\n gcd = math.gcd(sampling_rate, fps)\n divisor_waveform = sampling_rate // gcd * divisor_unet\n\n waveform_len = waveform.shape[0]\n window_len = int(waveform_len / sampling_rate * fps)\n waveform_len_fit = math.ceil(waveform_len / divisor_waveform) * divisor_waveform\n\n if waveform_len_fit > waveform_len:\n tmp = torch.zeros(waveform_len_fit)\n tmp[:waveform_len] = waveform[:]\n waveform = tmp\n\n return FittedWaveform(waveform=waveform, window_size=window_len)" }, { "identifier": "load_audio", "path": "said/util/audio.py", "snippet": "def load_audio(audio_path: str, sampling_rate: int) -> torch.FloatTensor:\n \"\"\"Load the audio file\n\n Parameters\n ----------\n audio_path : str\n Path of the audio file\n sampling_rate : int\n Sampling rate of the output audio wave\n\n Returns\n -------\n torch.FloatTensor\n (T_a), Mono waveform\n \"\"\"\n waveform, sr = torchaudio.load(audio_path)\n if sr != sampling_rate:\n waveform = torchaudio.functional.resample(waveform, sr, sampling_rate)\n waveform_mono = torch.mean(waveform, dim=0)\n return waveform_mono" }, { "identifier": "load_blendshape_coeffs", "path": "said/util/blendshape.py", "snippet": "def load_blendshape_coeffs(coeffs_path: str) -> torch.FloatTensor:\n \"\"\"Load the blendshape coefficients file\n\n Parameters\n ----------\n coeffs_path : str\n Path of the blendshape coefficients file (csv format)\n\n Returns\n -------\n torch.FloatTensor\n (T_b, num_classes), Blendshape coefficients\n \"\"\"\n df = pd.read_csv(coeffs_path)\n coeffs = torch.FloatTensor(df.values)\n return coeffs" }, { "identifier": "save_blendshape_coeffs", "path": "said/util/blendshape.py", "snippet": "def save_blendshape_coeffs(\n coeffs: np.ndarray, classes: List[str], output_path: str\n) -> None:\n \"\"\"Save the blendshape coefficients into the file\n\n Parameters\n ----------\n coeffs : np.ndarray\n (T_b, num_classes), Blendshape coefficients\n classes : List[str]\n List of the class names of the coefficients\n output_path : str\n Path of the output file\n \"\"\"\n pout = pd.DataFrame(coeffs, columns=classes)\n pout.to_csv(output_path, index=False)" }, { "identifier": "save_blendshape_coeffs_image", "path": "said/util/blendshape.py", "snippet": "def save_blendshape_coeffs_image(coeffs: np.ndarray, output_path: str) -> None:\n \"\"\"Save the blendshape coefficients into the image file\n\n Parameters\n ----------\n coeffs : np.ndarray\n (T_b, num_classes), Blendshape coefficients\n output_path : str\n Path of the output file\n \"\"\"\n orig = (255 * coeffs.transpose()).round()\n img = Image.fromarray(orig).convert(\"L\")\n img.save(output_path)" } ]

[ { "identifier": "Sam", "path": "SAMed/segment_anything/modeling/sam.py", "snippet": "class Sam(nn.Module):\n mask_threshold: float = 0.0\n image_format: str = \"RGB\"\n\n def __init__(\n self,\n image_encoder: ImageEncoderViT,\n prompt_encoder: PromptEncoder,\n mask_decoder: MaskDecoder,\n pixel_mean: List[float] = [123.675, 116.28, 103.53],\n pixel_std: List[float] = [58.395, 57.12, 57.375],\n ) -> None:\n \"\"\"\n SAM predicts object masks from an image and input prompts.\n\n Arguments:\n image_encoder (ImageEncoderViT): The backbone used to encode the\n image into image embeddings that allow for efficient mask prediction.\n prompt_encoder (PromptEncoder): Encodes various types of input prompts.\n mask_decoder (MaskDecoder): Predicts masks from the image embeddings\n and encoded prompts.\n pixel_mean (list(float)): Mean values for normalizing pixels in the input image.\n pixel_std (list(float)): Std values for normalizing pixels in the input image.\n \"\"\"\n super().__init__()\n self.image_encoder = image_encoder\n self.prompt_encoder = prompt_encoder\n self.mask_decoder = mask_decoder\n self.register_buffer(\"pixel_mean\", torch.Tensor(pixel_mean).view(-1, 1, 1), False)\n self.register_buffer(\"pixel_std\", torch.Tensor(pixel_std).view(-1, 1, 1), False)\n\n @property\n def device(self) -> Any:\n return self.pixel_mean.device\n\n def forward(self, batched_input, multimask_output, image_size):\n if isinstance(batched_input, list):\n outputs = self.forward_test(batched_input, multimask_output)\n else:\n outputs = self.forward_train(batched_input, multimask_output, image_size)\n return outputs\n\n def forward_train(self, batched_input, multimask_output, image_size):\n input_images = self.preprocess(batched_input)\n image_embeddings = self.image_encoder(input_images)\n sparse_embeddings, dense_embeddings = self.prompt_encoder(\n points=None, boxes=None, masks=None\n )\n low_res_masks, iou_predictions = self.mask_decoder(\n image_embeddings=image_embeddings,\n image_pe=self.prompt_encoder.get_dense_pe(),\n sparse_prompt_embeddings=sparse_embeddings,\n dense_prompt_embeddings=dense_embeddings,\n multimask_output=multimask_output\n )\n masks = self.postprocess_masks(\n low_res_masks,\n input_size=(image_size, image_size),\n original_size=(image_size, image_size)\n )\n outputs = {\n 'masks': masks,\n 'iou_predictions': iou_predictions,\n 'low_res_logits': low_res_masks\n }\n return outputs\n\n @torch.no_grad()\n def forward_test(\n self,\n batched_input: List[Dict[str, Any]],\n multimask_output: bool,\n ) -> List[Dict[str, torch.Tensor]]:\n \"\"\"\n Predicts masks end-to-end from provided images and prompts.\n If prompts are not known in advance, using SamPredictor is\n recommended over calling the model directly.\n\n Arguments:\n batched_input (list(dict)): A list over input images, each a\n dictionary with the following keys. A prompt key can be\n excluded if it is not present.\n 'image': The image as a torch tensor in 3xHxW format,\n already transformed for input to the model.\n 'original_size': (tuple(int, int)) The original size of\n the image before transformation, as (H, W).\n 'point_coords': (torch.Tensor) Batched point prompts for\n this image, with shape BxNx2. Already transformed to the\n input frame of the model.\n 'point_labels': (torch.Tensor) Batched labels for point prompts,\n with shape BxN.\n 'boxes': (torch.Tensor) Batched box inputs, with shape Bx4.\n Already transformed to the input frame of the model.\n 'mask_inputs': (torch.Tensor) Batched mask inputs to the model,\n in the form Bx1xHxW.\n multimask_output (bool): Whether the model should predict multiple\n disambiguating masks, or return a single mask.\n\n Returns:\n (list(dict)): A list over input images, where each element is\n as dictionary with the following keys.\n 'masks': (torch.Tensor) Batched binary mask predictions,\n with shape BxCxHxW, where B is the number of input promts,\n C is determiend by multimask_output, and (H, W) is the\n original size of the image.\n 'iou_predictions': (torch.Tensor) The model's predictions\n of mask quality, in shape BxC.\n 'low_res_logits': (torch.Tensor) Low resolution logits with\n shape BxCxHxW, where H=W=256. Can be passed as mask input\n to subsequent iterations of prediction.\n \"\"\"\n input_images = torch.stack([self.preprocess(x[\"image\"]) for x in batched_input], dim=0)\n image_embeddings = self.image_encoder(input_images)\n\n outputs = []\n for image_record, curr_embedding in zip(batched_input, image_embeddings):\n if \"point_coords\" in image_record:\n points = (image_record[\"point_coords\"], image_record[\"point_labels\"])\n else:\n points = None\n sparse_embeddings, dense_embeddings = self.prompt_encoder(\n points=points,\n boxes=image_record.get(\"boxes\", None),\n masks=image_record.get(\"mask_inputs\", None),\n )\n low_res_masks, iou_predictions = self.mask_decoder(\n image_embeddings=curr_embedding.unsqueeze(0),\n image_pe=self.prompt_encoder.get_dense_pe(),\n sparse_prompt_embeddings=sparse_embeddings,\n dense_prompt_embeddings=dense_embeddings,\n multimask_output=multimask_output,\n )\n masks = self.postprocess_masks(\n low_res_masks,\n input_size=image_record[\"image\"].shape[-2:],\n original_size=image_record[\"original_size\"],\n )\n masks = masks > self.mask_threshold\n outputs.append(\n {\n \"masks\": masks,\n \"iou_predictions\": iou_predictions,\n \"low_res_logits\": low_res_masks,\n }\n )\n return outputs\n\n def postprocess_masks(\n self,\n masks: torch.Tensor,\n input_size: Tuple[int, ...],\n original_size: Tuple[int, ...],\n ) -> torch.Tensor:\n \"\"\"\n Remove padding and upscale masks to the original image size.\n\n Arguments:\n masks (torch.Tensor): Batched masks from the mask_decoder,\n in BxCxHxW format.\n input_size (tuple(int, int)): The size of the image input to the\n model, in (H, W) format. Used to remove padding.\n original_size (tuple(int, int)): The original size of the image\n before resizing for input to the model, in (H, W) format.\n\n Returns:\n (torch.Tensor): Batched masks in BxCxHxW format, where (H, W)\n is given by original_size.\n \"\"\"\n masks = F.interpolate(\n masks,\n (self.image_encoder.img_size, self.image_encoder.img_size),\n mode=\"bilinear\",\n align_corners=False,\n )\n masks = masks[..., : input_size[0], : input_size[1]]\n masks = F.interpolate(masks, original_size, mode=\"bilinear\", align_corners=False)\n return masks\n\n def preprocess(self, x: torch.Tensor) -> torch.Tensor:\n \"\"\"Normalize pixel values and pad to a square input.\"\"\"\n # Normalize colors\n x = (x - self.pixel_mean) / self.pixel_std\n\n # Pad\n h, w = x.shape[-2:]\n padh = self.image_encoder.img_size - h\n padw = self.image_encoder.img_size - w\n x = F.pad(x, (0, padw, 0, padh))\n return x" }, { "identifier": "calculate_stability_score", "path": "SAMed/segment_anything/utils/amg.py", "snippet": "def calculate_stability_score(\n masks: torch.Tensor, mask_threshold: float, threshold_offset: float\n) -> torch.Tensor:\n \"\"\"\n Computes the stability score for a batch of masks. The stability\n score is the IoU between the binary masks obtained by thresholding\n the predicted mask logits at high and low values.\n \"\"\"\n # One mask is always contained inside the other.\n # Save memory by preventing unnecesary cast to torch.int64\n intersections = (\n (masks > (mask_threshold + threshold_offset))\n .sum(-1, dtype=torch.int16)\n .sum(-1, dtype=torch.int32)\n )\n unions = (\n (masks > (mask_threshold - threshold_offset))\n .sum(-1, dtype=torch.int16)\n .sum(-1, dtype=torch.int32)\n )\n return intersections / unions" } ]

[ { "identifier": "User", "path": "quill_server/db/models.py", "snippet": "class User(Base):\n __tablename__ = \"user\"\n\n id: Mapped[UUID] = mapped_column(pg_UUID(as_uuid=True), primary_key=True, default=uuid4) # noqa: A003\n username: Mapped[str] = mapped_column(unique=True)\n password: Mapped[str]\n created_at: Mapped[datetime] = mapped_column(DateTime, default=func.now())\n\n def __repr__(self) -> str:\n return f\"<User(id={self.id} username={self.username})>\"" }, { "identifier": "GameMember", "path": "quill_server/realtime/room.py", "snippet": "class GameMember(BaseModel):\n \"\"\"Represents a user currently playing in a Quill room.\"\"\"\n\n user_id: str\n username: str" }, { "identifier": "Room", "path": "quill_server/realtime/room.py", "snippet": "class Room(BaseModel):\n \"\"\"Represents a Quill game room.\"\"\"\n\n room_id: str\n owner: GameMember\n users: list[GameMember]\n status: GameStatus\n\n @classmethod\n def new(cls: type[\"Room\"], owner: User) -> \"Room\":\n return cls(\n room_id=str(uuid4()),\n owner=_db_user_to_game_member(owner),\n users=[],\n status=GameStatus.LOBBY,\n )\n\n async def start(self) -> None:\n \"\"\"Start the game in this room.\"\"\"\n self.status = GameStatus.ONGOING\n logger.info(f\"Setting room:{self.room_id}:status = ONGOING\")\n await cache.client.set(f\"room:{self.room_id}:status\", str(self.status))\n\n async def end(self) -> None:\n \"\"\"End the game in this room.\"\"\"\n self.status = GameStatus.ENDED\n logger.info(f\"Setting room:{self.room_id}:status = ENDED\")\n await cache.client.set(f\"room:{self.room_id}:status\", str(self.status))\n\n async def join(self, user: User) -> None:\n \"\"\"Add a user to this room.\"\"\"\n # reject connection if the user is already in the room...\n if any([u.user_id == str(user.id) for u in self.users]):\n raise ValueError(\"User is already in this room\")\n # or if the game isn't in the lobby state anymore...\n elif self.status != GameStatus.LOBBY:\n raise ValueError(\"Room is no longer accepting members\")\n # or if the room already has 8 members\n elif len(self.users) == 8:\n raise ValueError(\"Maximum room capacity reached\")\n data = _db_user_to_game_member(user)\n self.users.append(data)\n logger.info(f\"Adding {data.username} to room:{self.room_id}\")\n await typing.cast(\n typing.Awaitable[int],\n cache.client.rpush(f\"room:{self.room_id}:users\", data.model_dump_json()),\n )\n\n async def leave(self, user: User) -> None:\n \"\"\"Remove a user from this room.\"\"\"\n data = _db_user_to_game_member(user)\n self.users.remove(data)\n logger.info(f\"Removing {data.username} from room:{self.room_id}\")\n res = await typing.cast(\n typing.Awaitable[int],\n cache.client.lrem(f\"room:{self.room_id}:users\", 1, data.model_dump_json()),\n )\n if res != 1:\n logger.warning(\n f\"Attempted removing {data.username} from room:{self.room_id} \"\n f\"but Redis gave a response != 1 ({res=})\"\n )\n\n async def to_redis(self) -> None:\n \"\"\"Writes the room to Redis.\"\"\"\n # all the dictionaries are being dumped to redis as JSON strings\n # room:id:users will be a list of JSON strings\n key = f\"room:{self.room_id}\"\n owner = self.owner.model_dump_json()\n users = [i.model_dump_json() for i in self.users]\n status = str(self.status)\n logger.info(f\"Writing {key} to Redis\")\n async with cache.client.pipeline(transaction=True) as pipe:\n pipe.set(f\"{key}:owner\", owner)\n pipe.set(f\"{key}:status\", str(status))\n if len(users) > 0:\n pipe.rpush(f\"{key}:users\", *users)\n await pipe.execute()\n logger.info(f\"Saved {key} to Redis\")\n\n @classmethod\n async def from_redis(cls: type[\"Room\"], room_id: str) -> typing.Optional[\"Room\"]:\n key = f\"room:{room_id}\"\n logger.info(f\"Fetching {key} from Redis\")\n status = await cache.client.get(f\"{key}:status\")\n if not status:\n logger.warning(f\"{key} does not exist in cache\")\n return\n owner_res = await cache.client.get(f\"{key}:owner\")\n owner = loads(owner_res)\n # redis-py has incorrect return types set, so we need to cast here\n # https://github.com/redis/redis-py/issues/2933\n users_res = await typing.cast(\n typing.Awaitable[list[bytes]], cache.client.lrange(f\"{key}:users\", 0, -1)\n )\n users = [loads(i) for i in users_res]\n return cls(room_id=room_id, owner=owner, users=users, status=status.decode())" }, { "identifier": "ChatMessage", "path": "quill_server/realtime/room.py", "snippet": "class ChatMessage(BaseModel):\n \"\"\"Represents a message sent by a Quill player.\"\"\"\n\n username: str\n message: str\n has_guessed: bool" }, { "identifier": "_db_user_to_game_member", "path": "quill_server/realtime/room.py", "snippet": "def _db_user_to_game_member(user: User) -> GameMember:\n return GameMember(user_id=str(user.id), username=user.username)" }, { "identifier": "MessageResponse", "path": "quill_server/schema.py", "snippet": "class MessageResponse(BaseModel):\n message: str" } ]

[ { "identifier": "GaussianHead", "path": "PLEX/models/heads/distributions.py", "snippet": "class GaussianHead(nn.Module):\n def __init__(self, input_dim, output_dim, std_bounds,\n hidden_dim=None, squash=False):\n super().__init__()\n self.input_dim = input_dim\n self.output_dim = output_dim\n self.std_bounds = std_bounds\n self.squash = squash\n self.mean_head = _head(input_dim, output_dim, hidden_dim=hidden_dim)\n self.std_head = _head(input_dim, output_dim, hidden_dim=hidden_dim)\n\n def forward(self, x):\n mean = self.mean_head(x)\n std = _rescale(self.std_head(x), *self.std_bounds)\n dist = D.Normal(loc=mean, scale=std)\n # dist = D.Independent(dist, 1) # diagonal\n\n if self.squash:\n dist = TanhWrappedDistribution(dist)\n\n return dist" }, { "identifier": "GaussianMixtureHead", "path": "PLEX/models/heads/distributions.py", "snippet": "class GaussianMixtureHead(nn.Module):\n def __init__(self, num_components, input_dim, output_dim, std_bounds,\n hidden_dim=None, squash=False):\n super().__init__()\n self.num_components = num_components\n self.input_dim = input_dim\n self.output_dim = output_dim\n self.squash = squash\n self.std_bounds = std_bounds\n self.mean_heads = nn.ModuleList([\n _head(input_dim, output_dim, hidden_dim=hidden_dim)\n for _ in range(num_components)\n ])\n self.std_heads = nn.ModuleList([\n _head(input_dim, output_dim, hidden_dim=hidden_dim)\n for _ in range(num_components)\n ])\n self.logits_head = _head(input_dim, num_components, hidden_dim=hidden_dim)\n\n def forward(self, x):\n # mixture dim will come right after other batch dims\n batch_shape = tuple(x.shape[:-1])\n mixture_dim = len(batch_shape)\n\n # unnormalized logits to categorical distribution for mixing the modes\n logits = self.logits_head(x)\n mixture = D.Categorical(logits=logits)\n\n means = torch.stack([head(x) for head in self.mean_heads], dim=mixture_dim)\n stds = _rescale(\n torch.stack([head(x) for head in self.std_heads], dim=mixture_dim),\n *self.std_bounds\n )\n dists = D.Normal(loc=means, scale=stds)\n dists = D.Independent(dists, 1) # diagonal\n dist = D.MixtureSameFamily(mixture_distribution=mixture, component_distribution=dists)\n\n if self.squash:\n dist = TanhWrappedDistribution(dist)\n\n return dist" }, { "identifier": "R3M_Module", "path": "PLEX/models/encoders/vision.py", "snippet": "class R3M_Module(Module):\n def __init__(self, R3M_obj):\n super().__init__()\n self.R3M_obj = R3M_obj\n self.bn = nn.BatchNorm1d(self.R3M_obj.outdim)\n\n def forward(self, x, **kwargs):\n # \"Unprocess\" images so that they are in [0, 255] and upsample them to 224x224.\n x *= 255\n x = x.int()\n if (x.shape[-1] != 224 or x.shape[-2] != 224):\n preprocess = nn.Sequential(\n transforms.Resize(224)\n )\n x = preprocess(x)\n x = self.R3M_obj.forward(x, **kwargs)\n x = self.bn(x)\n return x\n\n def output_shape(self, input_shape=None):\n # The return dim of a BN layer is the same is its input dim (R3M's output dim)\n return [self.R3M_obj.outdim]" } ]

[ { "identifier": "ExcelFile", "path": "backend/SPO_KROT/metrics/models.py", "snippet": "class ExcelFile(models.Model):\n file = models.FileField(\n upload_to='metrics',\n unique=True,\n blank=True, null=True,\n validators=[FileExtensionValidator(['xlsx', 'xls', 'xlsm'])],\n )\n\n @property\n def filename(self):\n return self.file.name.split('/')[-1:][0]" }, { "identifier": "Measurements", "path": "backend/SPO_KROT/metrics/models.py", "snippet": "class Measurements(models.Model):\n \"\"\"Модель записи измерений из отчета, которые будут изменяться.\"\"\"\n class Meta:\n verbose_name = \"Измерение\"\n verbose_name_plural = \"Измерения\"\n\n operator = models.ForeignKey(\n Operator,\n on_delete=models.CASCADE,\n )\n report = models.ForeignKey(\n Report,\n on_delete=models.CASCADE,\n )\n voice_service_non_accessibility = models.FloatField(\n _(\"Доля неуспешных попыток установления голосового соединения\"),\n validators=PERCENTAGE_VALIDATOR\n )\n voice_service_cut_off = models.FloatField(\n _(\"Доля обрывов голосовых соединений\"),\n validators=PERCENTAGE_VALIDATOR\n )\n speech_quality_on_call = models.FloatField(\n _(\"Средняя разборчивость речи на соединение\"),\n )\n negative_mos_samples_ratio = models.FloatField(\n _(\"Доля голосовых соединений с низкой разборчивостью речи\"),\n validators=PERCENTAGE_VALIDATOR\n )\n undelivered_messages = models.FloatField(\n _(\"Доля недоставленных SMS сообщений\"),\n validators=PERCENTAGE_VALIDATOR\n )\n avg_sms_delivery_time = models.FloatField(\n _(\"Среднее время доставки SMS сообщений\"),\n )\n http_failure_session = models.FloatField(\n _(\"Доля неуспешных сессий по протоколу HTTP\"),\n validators=PERCENTAGE_VALIDATOR\n )\n http_ul_mean_userdata_rate = models.FloatField(\n _(\"Среднее значение скорости передачи данных от абонента\"),\n )\n http_dl_mean_userdata_rate = models.FloatField(\n _(\"Среднее значение скорости передачи данных к абоненту\"),\n )\n http_session_time = models.FloatField(\n _(\"Продолжительность успешной сессии\"),\n )\n number_of_test_voice_connections = models.IntegerField(\n _(\"Общее количество тестовых голосовых соединений \"),\n )\n number_of_voice_sequences = models.IntegerField(\n _(\"Общее количество голосовых последовательностей в оцениваемых соединениях\"),\n )\n voice_connections_with_low_intelligibility = models.IntegerField(\n _(\"Количество голосовых соединений с низкой разборчивостью\"),\n )\n number_of_sms_messages = models.IntegerField(\n _(\"Общее количество отправленных SMS - сообщений\"),\n )\n number_of_connections_attempts_http = models.IntegerField(\n _(\"Общее количество попыток соединений с сервером передачи данных HTTP\"),\n )\n number_of_test_sessions_http = models.IntegerField(\n _(\"Общее количество тестовых сессий по протоколу HTTP\"),\n )\n\n def __str__(self):\n return f\"Метрика {self.operator} из отчета {self.report}\"" }, { "identifier": "Operator", "path": "backend/SPO_KROT/metrics/models.py", "snippet": "class Operator(models.Model):\n \"\"\"Модель операторов связи для возможности добавления новых.\"\"\"\n class Meta:\n verbose_name = \"Оператор\"\n verbose_name_plural = \"Операторы\"\n\n name = models.CharField(\n _(\"Название оператора\"),\n max_length=50,\n blank=False, null=False,\n unique=True,\n )\n\n def __str__(self) -> models.CharField:\n return self.name" }, { "identifier": "Report", "path": "backend/SPO_KROT/metrics/models.py", "snippet": "class Report(models.Model):\n \"\"\"Модель отчетов для потенциального хранения информации об отчетах в БД.\"\"\"\n class Meta:\n verbose_name = \"Отчет\"\n verbose_name_plural = \"Отчеты\"\n\n title = models.CharField(\n _(\"Название отчета\"),\n max_length=200,\n blank=False, null=False,\n )\n region = models.CharField(\n _(\"Регион\"),\n max_length=50,\n blank=True, null=True,\n )\n city = models.CharField(\n _(\"Город\"),\n max_length=100,\n blank=True, null=True\n )\n start_date = models.DateField(\n _(\"Дата начала измерений\"),\n blank=True, null=True,\n )\n end_date = models.DateField(\n _(\"Дата конца измерений\"),\n blank=True, null=True,\n )\n publisher = models.ForeignKey(\n get_user_model(),\n on_delete=models.SET_NULL,\n null=True,\n )\n published = models.DateTimeField(\n auto_now_add=True,\n )\n\n def __str__(self):\n return f\"с {self.start_date} по {self.end_date} Отчет: {self.title}\"" }, { "identifier": "ExcelUploadSerializer", "path": "backend/SPO_KROT/metrics/serializers.py", "snippet": "class ExcelUploadSerializer(serializers.ModelSerializer):\n class Meta:\n model = ExcelFile\n fields = ('file',)" }, { "identifier": "ReportDetailSerializer", "path": "backend/SPO_KROT/metrics/serializers.py", "snippet": "class ReportDetailSerializer(serializers.ModelSerializer):\n class Meta:\n model = Report\n fields = ('publisher', \"title\", \"region\", \"city\", \"start_date\", \"end_date\", \"published\", 'measurements_set')\n depth = 2\n\n publisher = serializers.CharField()" }, { "identifier": "ReportListSerializer", "path": "backend/SPO_KROT/metrics/serializers.py", "snippet": "class ReportListSerializer(serializers.ModelSerializer):\n class Meta:\n model = Report\n fields = \"__all__\"" } ]

[ { "identifier": "filter_stripped_lines", "path": "hlm/utils/text_utils.py", "snippet": "def filter_stripped_lines(lines):\n return [_.strip() for _ in lines if len(_.strip()) > 0]" }, { "identifier": "unique_texts", "path": "hlm/utils/text_utils.py", "snippet": "def unique_texts(texts):\n return list(dict.fromkeys(texts))" }, { "identifier": "all_matched_pos", "path": "hlm/utils/text_utils.py", "snippet": "def all_matched_pos(pattern, text):\n if isinstance(pattern, (list, tuple)):\n pattern = \"(\" + \"|\".join(pattern) + \")\"\n return sorted([match.start() for match in re.finditer(pattern, text)])" } ]

[ { "identifier": "COLORS", "path": "arlin/analysis/visualization/colors.py", "snippet": "COLORS = [\n base[\"b\"],\n tableau[\"tab:orange\"],\n base[\"g\"],\n base[\"r\"],\n base[\"c\"],\n base[\"m\"],\n base[\"y\"],\n base[\"k\"],\n tableau[\"tab:blue\"],\n tableau[\"tab:green\"],\n tableau[\"tab:red\"],\n tableau[\"tab:purple\"],\n tableau[\"tab:brown\"],\n tableau[\"tab:pink\"],\n tableau[\"tab:gray\"],\n css4[\"brown\"],\n css4[\"salmon\"],\n css4[\"chocolate\"],\n css4[\"burlywood\"],\n css4[\"darkgoldenrod\"],\n css4[\"gold\"],\n css4[\"khaki\"],\n css4[\"yellow\"],\n css4[\"darkolivegreen\"],\n css4[\"chartreuse\"],\n css4[\"lime\"],\n css4[\"turquoise\"],\n css4[\"darkslategray\"],\n css4[\"cadetblue\"],\n css4[\"powderblue\"],\n css4[\"steelblue\"],\n css4[\"dodgerblue\"],\n css4[\"royalblue\"],\n css4[\"navy\"],\n css4[\"mediumblue\"],\n css4[\"slateblue\"],\n css4[\"blueviolet\"],\n css4[\"mediumorchid\"],\n css4[\"darkmagenta\"],\n css4[\"magenta\"],\n css4[\"deeppink\"],\n css4[\"palevioletred\"],\n]" }, { "identifier": "GraphData", "path": "arlin/analysis/visualization/visualization.py", "snippet": "class GraphData:\n \"\"\"Class to save data that can be graphed in matplotlib.\"\"\"\n\n def __init__(\n self,\n x: np.ndarray,\n y: np.ndarray,\n title: str,\n colors: Optional[List[str]] = None,\n legend: Optional[Dict] = None,\n cmap: Optional[str] = None,\n error_bars: Optional[List[float]] = None,\n xlabel: Optional[str] = None,\n ylabel: Optional[str] = None,\n showall: bool = False,\n ):\n \"\"\"Initialize a GraphData object.\n\n Args:\n x (np.ndarray): X axis data\n y (np.ndarray): Y axis data\n title (str): Title of the graph\n colors (Optional[List[str]], optional): Point color for each datapoint.\n Defaults to None.\n legend (Optional[Dict], optional): Add a legend to the side of the graph.\n Defaults to None.\n cmap (Optional[str], optional): Add a colorbar to the side of the graph.\n Defaults to None.\n error_bars (Optional[List[float]], optional): Error bars for each datapoint.\n Defaults to None.\n xlabel (Optional[str], optional): Xlabels for the graph. Defaults to None.\n ylabel (Optional[str], optional): Ylabels for the graph. Defaults to None.\n showall (bool, optional): Show all axis in the figure. Defaults to False.\n \"\"\"\n self.x = x\n self.y = y\n self.title = title\n self.colors = colors\n self.legend = legend\n self.cmap = cmap\n self.error_bars = error_bars\n self.xlabel = xlabel\n self.ylabel = ylabel\n self.showall = showall\n\n def get_data(self) -> Dict[str, Any]:\n \"\"\"Get the data from within this GraphData.\n\n Returns:\n Dict[str, Any]: Dictionary with all stored class information.\n \"\"\"\n data = {\n \"x\": self.x,\n \"y\": self.y,\n \"title\": self.title,\n \"colors\": self.colors,\n \"legend\": self.legend,\n \"cmap\": self.cmap,\n \"error_bars\": self.error_bars,\n \"xlabel\": self.xlabel,\n \"ylabel\": self.ylabel,\n \"showall\": self.showall,\n }\n\n return data" }, { "identifier": "graph_individual_data", "path": "arlin/analysis/visualization/visualization.py", "snippet": "def graph_individual_data(\n filename: str,\n data: GraphData,\n) -> None:\n \"\"\"Graph given GraphData to a single plot and save a PNG to the given file.\n\n Args:\n data (GraphData): Data necessary to graph and individual plot.\n filename (str): Name for the PNG file.\n \"\"\"\n _ = plt.scatter(data.x, data.y, c=data.colors, cmap=data.cmap, s=1)\n\n if not data.showall:\n plt.axis(\"off\")\n else:\n plt.xticks(data.x)\n plt.xticks(rotation=90)\n plt.xlabel(data.xlabel)\n plt.ylabel(data.ylabel)\n\n plt.title(data.title)\n\n if data.legend is not None:\n data.legend.update({\"bbox_to_anchor\": (1.05, 1.0), \"loc\": \"upper left\"})\n plt.legend(**data.legend)\n\n if data.cmap is not None:\n plt.colorbar()\n\n if data.error_bars is not None:\n for i in range(len(data.x)):\n plt.errorbar(\n data.x[i],\n data.y[i],\n yerr=data.error_bars[i],\n ecolor=data.colors[i],\n mec=data.colors[i],\n mfc=data.colors[i],\n fmt=\"o\",\n capsize=5,\n )\n\n plt.tight_layout()\n\n logging.info(f\"Saving individual graph png to {filename}...\")\n os.makedirs(os.path.dirname(filename), exist_ok=True)\n plt.savefig(filename, bbox_inches=\"tight\")\n plt.close()" }, { "identifier": "graph_multiple_data", "path": "arlin/analysis/visualization/visualization.py", "snippet": "def graph_multiple_data(\n file_path: str,\n figure_title: str,\n graph_datas: List[GraphData],\n horizontal: bool = True,\n) -> None:\n \"\"\"Graph multiple GraphDatas in the same figure.\n\n Args:\n file_path (str): Path to save figure to.\n figure_title (str): Title of the combination graph.\n graph_datas (List[GraphData]): GraphDatast to graph together.\n horizontal (bool, optional): Whether the figure should be wider than it is tall.\n Defaults to True.\n \"\"\"\n num_plots = len(graph_datas)\n nrows, ncols = _find_subplot_dims(num_plots, horizontal)\n\n fig, axs = plt.subplots(int(nrows), int(ncols))\n fig.set_size_inches(6 * ncols, 4 * nrows)\n fig.suptitle(figure_title)\n\n cur_num = 0\n for irow in range(int(nrows)):\n for icol in range(int(ncols)):\n data = graph_datas[cur_num]\n\n if horizontal and nrows == 1:\n axis = axs[icol]\n elif not horizontal and ncols == 1:\n axis = axs[irow]\n else:\n axis = axs[irow, icol]\n\n scp = axis.scatter(data.x, data.y, c=data.colors, cmap=data.cmap, s=1)\n\n axis.set_title(data.title)\n axis.title.set_size(10)\n\n if not data.showall:\n axis.axis(\"off\")\n else:\n axis.set_xticks(data.x)\n axis.set_xticklabels(axis.get_xticks(), rotation=90)\n axis.set_xlabel(data.xlabel)\n axis.set_ylabel(data.ylabel)\n\n if data.legend is not None: # and len(data.legend[\"labels\"]) < 4:\n extra_legends = {\"bbox_to_anchor\": (1.05, 1.0), \"loc\": \"upper left\"}\n data.legend.update(extra_legends)\n axis.legend(**data.legend)\n\n if data.cmap is not None:\n plt.colorbar(scp, ax=axis)\n\n if data.error_bars is not None:\n for i in range(len(data.x)):\n axis.errorbar(\n data.x[i],\n data.y[i],\n yerr=data.error_bars[i],\n ecolor=data.colors[i],\n mec=data.colors[i],\n mfc=data.colors[i],\n fmt=\"o\",\n capsize=5,\n )\n\n plt.tight_layout()\n\n cur_num += 1\n\n logging.info(f\"Saving combination graph png to {file_path}...\")\n os.makedirs(os.path.dirname(file_path), exist_ok=True)\n plt.savefig(file_path, bbox_inches=\"tight\")\n plt.close()" }, { "identifier": "_find_subplot_dims", "path": "arlin/analysis/visualization/visualization.py", "snippet": "def _find_subplot_dims(num_plots: int, horizontal: bool) -> Tuple[int, int]:\n \"\"\"Find the optimal dimensions needed for the subplot.\n\n Args:\n num_plots (int): Number of plots to graph.\n horizontal (bool): Should the figure be wider or taller?\n\n Returns:\n Tuple[int, int]: Height dimension, Width dimension\n \"\"\"\n # if number is a square number\n if num_plots == isqrt(num_plots) ** 2:\n return sqrt(num_plots), sqrt(num_plots)\n\n if num_plots == 2:\n dim_long = 2\n dim_short = 1\n elif num_plots % 2 == 0:\n dim_long = int(num_plots / 2)\n dim_short = 2\n else:\n dim_long = num_plots\n dim_short = 1\n\n if horizontal:\n return dim_short, dim_long\n else:\n return dim_long, dim_short" } ]

[ { "identifier": "Giftify", "path": "bot.py", "snippet": "class Giftify(GiftifyHelper, commands.AutoShardedBot):\r\n user: discord.ClientUser\r\n\r\n colour: int = 0xCB3045\r\n __version_info__ = \"1.1.4\"\r\n\r\n def __init__(\r\n self,\r\n *,\r\n log_handler: LogHandler,\r\n pool: asyncpg.Pool,\r\n session: aiohttp.ClientSession,\r\n amari_client: AmariClient,\r\n ) -> None:\r\n self._log_handler = log_handler\r\n self._pool = pool\r\n self._session = session\r\n self._amari_client = amari_client\r\n\r\n intents = discord.Intents(messages=True, emojis=True, guilds=True)\r\n allowed_mentions = discord.AllowedMentions(everyone=False, roles=False, users=True, replied_user=False)\r\n member_cache_flags = discord.MemberCacheFlags.from_intents(intents=intents)\r\n\r\n sentry_sdk.init(\r\n dsn=os.environ[\"SENTRY_DSN\"],\r\n integrations=[\r\n LoggingIntegration(\r\n level=logging.INFO,\r\n event_level=logging.ERROR,\r\n )\r\n ],\r\n traces_sample_rate=1.0,\r\n )\r\n\r\n super().__init__(\r\n command_prefix=commands.when_mentioned,\r\n tree_cls=CommandTree,\r\n help_command=None,\r\n description=\"A giveaway bot for hosting giveaways.\",\r\n intents=intents,\r\n allowed_mentions=allowed_mentions,\r\n chunk_guilds_at_startup=False,\r\n max_messages=None,\r\n activity=discord.CustomActivity(name=\"\\N{LINK SYMBOL} https://giftifybot.vercel.app\"),\r\n member_cache_flags=member_cache_flags,\r\n owner_ids=OWNER_IDS,\r\n )\r\n\r\n @property\r\n def log_handler(self) -> LogHandler:\r\n return self._log_handler\r\n\r\n @property\r\n def pool(self) -> asyncpg.Pool:\r\n return self._pool\r\n\r\n @property\r\n def session(self) -> aiohttp.ClientSession:\r\n return self._session\r\n\r\n @property\r\n def amari_client(self) -> AmariClient:\r\n return self._amari_client\r\n\r\n @property\r\n def timer_cog(self) -> TimerManager:\r\n return self.get_cog(\"TimerManager\") # type: ignore\r\n\r\n def run(self) -> None:\r\n raise NotImplementedError(\"Please use `.start()` instead.\")\r\n\r\n async def on_ready(self) -> None:\r\n self.log_handler.log.info(\"%s got a ready event at %s\", self.user.name, datetime.datetime.now())\r\n\r\n async def on_resume(self) -> None:\r\n self.log_handler.log.info(\"%s got a resume event at %s\", self.user.name, datetime.datetime.now())\r\n\r\n async def on_command_error(self, ctx: commands.Context, error: commands.CommandError) -> None:\r\n if isinstance(error, commands.CommandInvokeError):\r\n origin_ = error.original\r\n assert ctx.command is not None\r\n if not isinstance(origin_, discord.HTTPException):\r\n print(f\"In {ctx.command.qualified_name}:\", file=sys.stderr)\r\n traceback.print_tb(origin_.__traceback__)\r\n print(f\"{origin_.__class__.__name__}: {origin_}\", file=sys.stderr)\r\n sentry_sdk.capture_exception(error)\r\n\r\n async def start(self) -> None:\r\n await super().start(token=os.environ[\"TOKEN\"], reconnect=True)\r\n\r\n async def setup_hook(self) -> None:\r\n self.start_time: datetime.datetime = datetime.datetime.now(datetime.timezone.utc)\r\n\r\n self.bot_app_info = await self.application_info()\r\n self.owner_ids = OWNER_IDS\r\n\r\n async def get_or_fetch_user(self, user_id: int) -> Optional[discord.User]:\r\n \"\"\"Looks up a user in cache or fetches if not found.\r\n\r\n Parameters\r\n -----------\r\n user_id: int\r\n The user ID to search for.\r\n\r\n Returns\r\n ---------\r\n Optional[User]\r\n The user or None if not found.\r\n \"\"\"\r\n\r\n user = self.get_user(user_id)\r\n if user is not None:\r\n return user\r\n\r\n try:\r\n user = await self.fetch_user(user_id)\r\n except discord.HTTPException:\r\n return None\r\n else:\r\n return user\r\n\r\n async def get_or_fetch_member(self, guild: discord.Guild, member_id: int) -> Optional[discord.Member]:\r\n \"\"\"Looks up a member in cache or fetches if not found.\r\n\r\n Parameters\r\n -----------\r\n guild: Guild\r\n The guild to look in.\r\n member_id: int\r\n The member ID to search for.\r\n\r\n Returns\r\n ---------\r\n Optional[Member]\r\n The member or None if not found.\r\n \"\"\"\r\n\r\n member = guild.get_member(member_id)\r\n if member is not None:\r\n return member\r\n\r\n shard: discord.ShardInfo = self.get_shard(guild.shard_id) # type: ignore # will never be None\r\n if shard.is_ws_ratelimited():\r\n try:\r\n member = await guild.fetch_member(member_id)\r\n except discord.HTTPException:\r\n return None\r\n else:\r\n return member\r\n\r\n members = await guild.query_members(limit=1, user_ids=[member_id], cache=True)\r\n if not members:\r\n return None\r\n return members[0]\r" }, { "identifier": "GuildDonationConfig", "path": "models/donation_settings.py", "snippet": "class GuildDonationConfig:\n \"\"\"Represents the donation configuration settings for a guild.\n\n Parameters\n ----------\n bot: Giftify\n The bot instance handling the configuration.\n guild discord.Guild\n The guild associated with the configuration.\n category: str\n The category or name of the donation configuration.\n symbol: str\n The symbol or identifier of the donation category.\n roles: Dict[int, discord.Role]\n A dictionary mapping of amount to `discord.Role`.\n managers: List[discord.Role]\n A list of `discord.Role` objects representing the roles with donation management permissions.\n logging: Optional[discord.TextChannel]\n An optional `discord.TextChannel` object used for logging donation events.\n \"\"\"\n\n __slots__: Tuple[str, ...] = (\n \"bot\",\n \"guild\",\n \"category\",\n \"symbol\",\n \"roles\",\n \"managers\",\n \"logging\",\n )\n\n def __init__(\n self,\n bot: Giftify,\n *,\n guild: discord.Guild,\n category: str,\n symbol: str,\n roles: Dict[int, discord.Role],\n managers: List[discord.Role],\n logging: Optional[discord.TextChannel] = None,\n ):\n self.bot = bot\n self.guild = guild\n self.category = category\n self.symbol = symbol\n self.roles = roles\n self.managers = managers\n self.logging = logging\n\n def __str__(self):\n return self.category\n\n def __repr__(self):\n return f\"<GuildDonationConfig guild={self.guild!r}> category={self.category}\"\n\n @classmethod\n async def create(\n cls, guild_id: int, category: str, bot: Giftify, *, symbol: Optional[str] = None\n ) -> \"GuildDonationConfig\":\n record = await bot.pool.fetchrow(\n \"INSERT INTO donation_configs (guild, category, symbol) VALUES ($1, $2, $3) RETURNING *\",\n guild_id,\n category,\n symbol,\n )\n instance = await cls.from_record(bot, record=record)\n assert instance is not None\n return instance\n\n @classmethod\n async def from_record(\n cls, bot: Giftify, *, record: asyncpg.Record\n ) -> Optional[\"GuildDonationConfig\"]:\n guild = bot.get_guild(record[\"guild\"])\n if not guild:\n return None\n\n category = record[\"category\"]\n symbol = record[\"symbol\"]\n roles = {}\n managers = []\n logging: Optional[discord.TextChannel] = (\n guild.get_channel(record[\"logging\"]) if record[\"logging\"] else None\n ) # type: ignore\n\n for amount, role_id in record[\"roles\"].items():\n if role := guild.get_role(role_id):\n roles[int(amount)] = role\n\n for role_id in record[\"managers\"]:\n if role := guild.get_role(role_id):\n managers.append(role)\n\n return cls(\n bot,\n guild=guild,\n category=category,\n symbol=symbol,\n roles=roles,\n managers=managers,\n logging=logging,\n )\n\n async def update(\n self,\n key: str,\n value: Union[\n str, discord.TextChannel, Dict[int, discord.Role], List[discord.Role]\n ],\n ) -> None:\n \"\"\"\n Update a specific attribute of the GuildDonationConfig.\n\n Parameters\n ----------\n key: str\n The attribute name to be updated. Should be one of \"category\", \"symbol\", \"logging\", \"roles\", or \"managers\".\n value: Union[str, discord.TextChannel, Dict[int, discord.Role], List[discord.Role]]\n The new value for the attribute.\n\n Raises\n ------\n ValueError\n If an invalid key is provided.\n If the value is not of the expected type for the specified key.\n\n Returns\n -------\n None\n \"\"\"\n if key not in [\"category\", \"symbol\", \"logging\", \"roles\", \"managers\"]:\n raise ValueError(\n \"Invalid key provided. Valid keys are 'category', 'symbol', 'logging', 'roles', and 'managers'.\"\n )\n\n if key in [\"category\", \"symbol\"]:\n await self._update_config(key, str(value))\n setattr(self, key, value)\n elif key == \"logging\":\n if not isinstance(value, discord.TextChannel):\n raise ValueError(\"Value for 'logging' must be a discord.TextChannel.\")\n self.logging = value\n\n await self._update_config(key, value.id)\n elif key == \"roles\":\n if not isinstance(value, dict):\n raise ValueError(\"Value for 'roles' must be a dictionary.\")\n self.roles = value\n role_values = {amount: role.id for amount, role in value.items()}\n await self._update_config(key, role_values)\n elif key == \"managers\":\n if not isinstance(value, list):\n raise ValueError(\"Value for 'managers' must be a list.\")\n self.managers = value\n role_ids = [role.id for role in value]\n await self._update_config(key, role_ids)\n\n async def _update_config(\n self, key: str, value: Union[str, int, List[int], Dict[int, int]]\n ) -> None:\n await self.bot.pool.execute(\n f\"UPDATE donation_configs SET {key} = $1 WHERE guild = $2 AND category = $3\",\n value,\n self.guild.id,\n self.category,\n )\n\n async def delete(self):\n await self.bot.pool.execute(\n \"DELETE FROM donation_configs WHERE guild = $1 AND category = $2\",\n self.guild.id,\n self.category,\n )\n\n async def reset(self):\n await self.bot.pool.execute(\n \"DELETE FROM donations WHERE guild = $1 AND category = $2\",\n self.guild.id,\n self.category,\n )" }, { "identifier": "DonationCategoryTransformer", "path": "utils/transformers.py", "snippet": "class DonationCategoryTransformer(app_commands.Transformer):\r\n async def transform(\r\n self, interaction: Interaction, value: str\r\n ) -> GuildDonationConfig:\r\n assert interaction.guild is not None\r\n\r\n config = interaction.client.get_donation_config(interaction.guild, value)\r\n if not config:\r\n raise InvalidDonationCategoryError(\r\n f\"The donation category of name {value} does not exist!\",\r\n )\r\n\r\n return config\r\n\r\n async def autocomplete(\r\n self,\r\n interaction: Interaction,\r\n current: str,\r\n ) -> List[app_commands.Choice[str]]:\r\n assert interaction.guild is not None\r\n\r\n return [\r\n app_commands.Choice(name=category, value=category)\r\n for category in interaction.client.get_guild_donation_categories(\r\n interaction.guild\r\n )\r\n if current.lower() in category.lower()\r\n ]\r" }, { "identifier": "Interaction", "path": "utils/tree.py", "snippet": "class CommandTree(app_commands.CommandTree):\r\n async def on_error(\r\n self,\r\n interaction: Interaction,\r\n error: app_commands.AppCommandError,\r\n ) -> None:\r" } ]

[ { "identifier": "get_device", "path": "utilities/device.py", "snippet": "def get_device():\n\n if((not USE_CUDA) or (TORCH_CUDA_DEVICE is None)):\n return TORCH_CPU_DEVICE\n else:\n return TORCH_CUDA_DEVICE" }, { "identifier": "get_lr", "path": "utilities/lr_scheduling.py", "snippet": "def get_lr(optimizer):\n\n for param_group in optimizer.param_groups:\n return param_group['lr']" }, { "identifier": "parse_train_args", "path": "utilities/argument_funcs.py", "snippet": "def parse_train_args():\n\n parser = argparse.ArgumentParser()\n\n parser.add_argument(\"-input_dir\", type=str, default=\"./dataset/dataset/JSF_SATB\", help=\"Folder of preprocessed and pickled midi files\")\n parser.add_argument(\"-output_dir\", type=str, default=\"./baseline_3loss\", help=\"Folder to save model weights. Saves one every epoch\")\n parser.add_argument(\"-weight_modulus\", type=int, default=1, help=\"How often to save epoch weights (ex: value of 10 means save every 10 epochs)\")\n parser.add_argument(\"-print_modulus\", type=int, default=1, help=\"How often to print train results for a batch (batch loss, learn rate, etc.)\")\n parser.add_argument(\"-word2event\", type=str, default='./dataset/word2event.pkl', help='word table location: *.pkl')\n parser.add_argument(\"-n_workers\", type=int, default=2, help=\"Number of threads for the dataloader\")\n parser.add_argument(\"--force_cpu\", action=\"store_true\", help=\"Forces model to run on a cpu even when gpu is available\")\n parser.add_argument(\"--gpu\", default=[2], nargs='+', type=int, help=\"For Multi-GPUs training\")\n parser.add_argument(\"--no_tensorboard\", action=\"store_true\", help=\"Turns off tensorboard result reporting\")\n parser.add_argument('--scheduled_sampling', default=False, help='False means use teacher forcing, True means use scheduled_sampling')\n parser.add_argument(\"--scheduled_sampling_change_ratio\", default=0.5, type=int, help='ratio about mix golden target with output')\n parser.add_argument(\"-continue_weights\", type=str, default=None, help=\"Model weights to continue training based on\")\n parser.add_argument(\"-continue_epoch\", type=int, default=None, help=\"Epoch the continue_weights model was at\")\n\n parser.add_argument(\"-lr\", type=float, default=None, help=\"Constant learn rate. Leave as None for a custom scheduler.\")\n parser.add_argument(\"-ce_smoothing\", type=float, default=None, help=\"Smoothing parameter for smoothed cross entropy loss (defaults to no smoothing)\")\n parser.add_argument(\"-batch_size\", type=int, default=2, help=\"Batch size per gpu to use\")\n parser.add_argument(\"-epochs\", type=int, default=300, help=\"Number of epochs to use\")\n\n parser.add_argument(\"-adv_train\", default=True, help='add discriminator loss')\n parser.add_argument(\"-only_Transformer\", default=False, help='use pure Transformer, default set to false, True only for test')\n parser.add_argument(\"-loss\", default=[0.4, 0.2, 0.8], nargs='+', type=float, help='weights of loss, the last element effect when adv train is True')\n\n parser.add_argument(\"--rpr\", action=\"store_true\", help=\"Use a modified Transformer for Relative Position Representations\")\n parser.add_argument(\"-max_sequence\", type=int, default=2048, help=\"Maximum midi sequence to consider\")\n parser.add_argument(\"-n_layers\", type=int, default=6, help=\"Number of decoder layers to use\")\n parser.add_argument(\"-num_heads\", type=int, default=8, help=\"Number of heads to use for multi-head attention\")\n parser.add_argument(\"-d_model\", type=int, default=512, help=\"Dimension of the model (output dim of embedding layers, etc.)\")\n\n parser.add_argument(\"-dim_feedforward\", type=int, default=1024, help=\"Dimension of the feedforward layer\")\n\n parser.add_argument(\"-dropout\", type=float, default=0.1, help=\"Dropout rate\")\n\n parser.add_argument(\"--metrics\", default=False, help=\"evaluate TER(token error rate)\")\n\n return parser.parse_args()" }, { "identifier": "parse_eval_args", "path": "utilities/argument_funcs.py", "snippet": "def parse_eval_args():\n\n parser = argparse.ArgumentParser()\n\n parser.add_argument(\"-dataset_dir\", type=str, default=\"./dataset/dataset/JSF_SATB\", help=\"Folder of preprocessed and pickled midi files\")\n parser.add_argument(\"-model_weights\", type=str, default=\"./baseline_loss3_CBSATBoutput_0.4_0.2_1/weights/epoch_0110.pickle\", help=\"Pickled model weights file saved with torch.save and model.state_dict()\")\n parser.add_argument(\"-n_workers\", type=int, default=16, help=\"Number of threads for the dataloader\")\n parser.add_argument(\"--gpu\", default=[0], nargs='+', type=int, help=\"For Multi-GPUs testing\")\n parser.add_argument(\"--force_cpu\", action=\"store_true\", help=\"Forces model to run on a cpu even when gpu is available\")\n parser.add_argument(\"-word2event\", type=str, default='./dataset/word2event.pkl', help='word table location: *.pkl')\n parser.add_argument(\"-batch_size\", type=int, default=8, help=\"Batch size to use\")\n\n parser.add_argument(\"--rpr\", action=\"store_true\", help=\"Use a modified Transformer for Relative Position Representations\")\n parser.add_argument(\"-max_sequence\", type=int, default=2048, help=\"Maximum midi sequence to consider in the model\")\n parser.add_argument(\"-n_layers\", type=int, default=6, help=\"Number of decoder layers to use\")\n parser.add_argument(\"-num_heads\", type=int, default=8, help=\"Number of heads to use for multi-head attention\")\n parser.add_argument(\"-d_model\", type=int, default=512, help=\"Dimension of the model (output dim of embedding layers, etc.)\")\n\n parser.add_argument(\"-dim_feedforward\", type=int, default=1024, help=\"Dimension of the feedforward layer\")\n\n return parser.parse_args()" } ]

[ { "identifier": "Object", "path": "tools/project.py", "snippet": "class Object:\n def __init__(self, completed, name, **options):\n self.name = name\n self.completed = completed\n self.options = {\n \"add_to_all\": True,\n \"cflags\": None,\n \"mw_version\": None,\n \"shiftjis\": True,\n \"source\": name,\n }\n self.options.update(options)" }, { "identifier": "ProjectConfig", "path": "tools/project.py", "snippet": "class ProjectConfig:\n def __init__(self):\n # Paths\n self.build_dir = Path(\"build\")\n self.src_dir = Path(\"src\")\n self.tools_dir = Path(\"tools\")\n\n # Tooling\n self.dtk_tag = None # Git tag\n self.build_dtk_path = None # If None, download\n self.compilers_tag = None # 1\n self.compilers_path = None # If None, download\n self.wibo_tag = None # Git tag\n self.wrapper = None # If None, download wibo on Linux\n self.sjiswrap_tag = None # Git tag\n self.sjiswrap_path = None # If None, download\n\n # Project config\n self.build_rels = True # Build REL files\n self.check_sha_path = None # Path to version.sha1\n self.config_path = None # Path to config.yml\n self.debug = False # Build with debug info\n self.generate_map = False # Generate map file(s)\n self.ldflags = None # Linker flags\n self.libs = None # List of libraries\n self.linker_version = None # mwld version\n self.version = None # Version name\n self.warn_missing_config = False # Warn on missing unit configuration\n self.warn_missing_source = False # Warn on missing source file\n\n # Progress output and progress.json config\n self.progress_all = True # Include combined \"all\" category\n self.progress_modules = True # Include combined \"modules\" category\n self.progress_each_module = (\n True # Include individual modules, disable for large numbers of modules\n )\n\n def validate(self):\n required_attrs = [\n \"build_dir\",\n \"src_dir\",\n \"tools_dir\",\n \"check_sha_path\",\n \"config_path\",\n \"ldflags\",\n \"linker_version\",\n \"libs\",\n \"version\",\n ]\n for attr in required_attrs:\n if getattr(self, attr) is None:\n sys.exit(f\"ProjectConfig.{attr} missing\")\n\n def find_object(self, name):\n for lib in self.libs:\n for obj in lib[\"objects\"]:\n if obj.name == name:\n return [lib, obj]\n return None\n\n def out_path(self):\n return self.build_dir / self.version" }, { "identifier": "calculate_progress", "path": "tools/project.py", "snippet": "def calculate_progress(config):\n out_path = config.out_path()\n build_config = load_build_config(config, out_path / \"config.json\")\n if not build_config:\n return\n\n class ProgressUnit:\n def __init__(self, name):\n self.name = name\n self.code_total = 0\n self.code_progress = 0\n self.data_total = 0\n self.data_progress = 0\n self.objects_progress = 0\n self.objects_total = 0\n self.objects = set()\n\n def add(self, build_obj):\n self.code_total += build_obj[\"code_size\"]\n self.data_total += build_obj[\"data_size\"]\n\n # Avoid counting the same object in different modules twice\n include_object = build_obj[\"name\"] not in self.objects\n if include_object:\n self.objects.add(build_obj[\"name\"])\n self.objects_total += 1\n\n if build_obj[\"autogenerated\"]:\n # Skip autogenerated objects\n return\n\n result = config.find_object(build_obj[\"name\"])\n if not result:\n return\n\n _, obj = result\n if not obj.completed:\n return\n\n self.code_progress += build_obj[\"code_size\"]\n self.data_progress += build_obj[\"data_size\"]\n if include_object:\n self.objects_progress += 1\n\n def code_frac(self):\n return self.code_progress / self.code_total\n\n def data_frac(self):\n return self.data_progress / self.data_total\n\n # Add DOL units\n all_progress = ProgressUnit(\"All\") if config.progress_all else None\n dol_progress = ProgressUnit(\"DOL\")\n for unit in build_config[\"units\"]:\n if all_progress:\n all_progress.add(unit)\n dol_progress.add(unit)\n\n # Add REL units\n rels_progress = ProgressUnit(\"Modules\") if config.progress_modules else None\n modules_progress = []\n for module in build_config[\"modules\"]:\n progress = ProgressUnit(module[\"name\"])\n modules_progress.append(progress)\n for unit in module[\"units\"]:\n if all_progress:\n all_progress.add(unit)\n if rels_progress:\n rels_progress.add(unit)\n progress.add(unit)\n\n # Print human-readable progress\n print(\"Progress:\")\n\n def print_category(unit):\n code_frac = unit.code_frac()\n data_frac = unit.data_frac()\n print(\n f\" {unit.name}: {code_frac:.2%} code, {data_frac:.2%} data ({unit.objects_progress} / {unit.objects_total} files)\"\n )\n print(f\" Code: {unit.code_progress} / {unit.code_total} bytes\")\n print(f\" Data: {unit.data_progress} / {unit.data_total} bytes\")\n\n if all_progress:\n print_category(all_progress)\n print_category(dol_progress)\n module_count = len(build_config[\"modules\"])\n if module_count > 0:\n print_category(rels_progress)\n if config.progress_each_module:\n for progress in modules_progress:\n print_category(progress)\n\n # Generate and write progress.json\n progress_json = {}\n\n def add_category(category, unit):\n progress_json[category] = {\n \"code\": unit.code_progress,\n \"code/total\": unit.code_total,\n \"data\": unit.data_progress,\n \"data/total\": unit.data_total,\n }\n\n if all_progress:\n add_category(\"all\", all_progress)\n add_category(\"dol\", dol_progress)\n if len(build_config[\"modules\"]) > 0:\n if rels_progress:\n add_category(\"modules\", rels_progress)\n if config.progress_each_module:\n for progress in modules_progress:\n add_category(progress.name, progress)\n with open(out_path / \"progress.json\", \"w\", encoding=\"utf-8\") as w:\n json.dump(progress_json, w, indent=4)" }, { "identifier": "generate_build", "path": "tools/project.py", "snippet": "def generate_build(config):\n build_config = load_build_config(config, config.out_path() / \"config.json\")\n generate_build_ninja(config, build_config)\n generate_objdiff_config(config, build_config)" }, { "identifier": "is_windows", "path": "tools/project.py", "snippet": "def is_windows():\n return os.name == \"nt\"" } ]

[ { "identifier": "Camera", "path": "cameras/camera.py", "snippet": "class Camera:\n config: CameraConfig\n\n def __init__(self, config : CameraConfig):\n self.config = config\n \n def rgb(self) -> NDArray:\n raise NotImplementedError('You should use a specified subclass!')\n\n def rgbd(self) -> Tuple[NDArray, NDArray]:\n raise NotImplementedError('You should use a specified subclass!')\n\n def depth_to_point_cloud(self, organized=False) -> Tuple[NDArray, NDArray]:\n \"\"\"\n organized: bool\n whether to keep the cloud in image shape (H,W,3)\n \"\"\"\n color_img, depth_img = self.rgbd()\n color_img = np.array(color_img, dtype=np.float32) / 255.0\n depth_img = np.array(depth_img / 1000, dtype=np.float32)\n\n # depth image resize to the color image size\n # just use the original size of depth image and color image\n # depth_img = cv2.resize(depth_img, (self.config.image_size_w, self.config.image_size_h), interpolation=cv2.INTER_NEAREST)\n # color_img = cv2.resize(color_img, (self.config.image_size_w, self.config.image_size_h), interpolation=cv2.INTER_LINEAR)\n # the scale should be considering again\n h, w = depth_img.shape\n\n # scale camera parameters\n scale_x = w / self.config.depth_w\n scale_y = h / self.config.depth_h\n\n fx = self.config.depth_fx * scale_x\n fy = self.config.depth_fy * scale_y\n\n x_offset = self.config.depth_ppx * scale_x\n y_offset = self.config.depth_ppy * scale_y\n\n indices = torch.from_numpy(np.indices((h, w), dtype=np.float32).transpose(1,2,0))\n \n z_e = torch.from_numpy(depth_img)\n x_e = (indices[..., 1] - x_offset) * z_e / fx\n y_e = (indices[..., 0] - y_offset) * z_e / fy\n point_cloud = torch.stack([x_e, y_e, z_e], axis=-1).numpy() # Shape: [H x W x 3]\n\n if not organized:\n color_img = color_img.reshape(-1, 3)\n point_cloud = point_cloud.reshape(-1, 3)\n return color_img, point_cloud\n\n @property\n def intrinsic(self):\n return {\n 'fx': self.config.fx,\n 'fy': self.config.fy,\n 'cx': self.config.ppx,\n 'cy': self.config.ppy,\n 'w': self.config.w,\n 'h': self.config.h\n }\n\n @property\n def depth_intrinsic(self):\n return {\n 'fx': self.config.depth_fx,\n 'fy': self.config.depth_fy,\n 'cx': self.config.depth_ppx,\n 'cy': self.config.depth_ppy,\n 'w': self.config.depth_w,\n 'h': self.config.depth_h\n }" }, { "identifier": "CameraConfig", "path": "cameras/camera.py", "snippet": "class CameraConfig(InstantiateConfig):\n \"\"\"Camera Config\"\"\"\n _target: Type = field(default_factory=lambda : Camera)\n # focal length of x axis\n fx: float = 0.0\n # focal length of y axis\n fy: float = 0.0\n # optical center of x\n ppx: float = 0.0\n # optical center of y\n ppy: float = 0.0\n # resolution x (width)\n w: int = 0.0\n # resolution y (height)\n h: int = 0.0\n # image size\n image_size_w: int = 1280\n image_size_h: int = 720\n # calibration matrix (camera on hand or camera on base)\n calibration: NDArray[np.float64] = None\n # depth camera focal length of x axis (optional)\n depth_fx: Optional[float] = None\n # depth camera focal length of y axis (optional)\n depth_fy: Optional[float] = None\n # depth camera ppx\n depth_ppx: Optional[float] = None\n # depth camera ppy\n depth_ppy: Optional[float] = None\n # depth resolution x (width)\n depth_w: Optional[int] = None\n # depth esolution y (height)\n depth_h: Optional[int] = None" }, { "identifier": "RealSenseCameraConfig", "path": "cameras/realsense.py", "snippet": "class RealSenseCameraConfig(CameraConfig):\n _target: Type = field(default_factory=lambda : RealSenseCamera)\n exposure: float = 500.0\n max_depth_value: float = 800.0" }, { "identifier": "MotionSolver", "path": "motion_solver/solver.py", "snippet": "class MotionSolver:\n config: MotionSolverConfig\n def __init__(self, config) -> None:\n self.config = config\n \n def ik(self, current_joints, target_pose : np.array) -> list:\n raise NotImplementedError" }, { "identifier": "PybulletMotionSolverConfig", "path": "motion_solver/solver.py", "snippet": "class PybulletMotionSolverConfig(MotionSolverConfig):\n _target: Type = field(default_factory=lambda : PybulletMotionSolver)\n upperlimits: Tuple = FrankaConstants.JOINT_LIMITS_UPPER.value\n lowerlimits: Tuple = FrankaConstants.JOINT_LIMITS_LOWER.value\n jointranges: Tuple = FrankaConstants.JOINT_RANGES.value\n robot_file: str = 'franka_panda/panda.urdf'" }, { "identifier": "InstantiateConfig", "path": "config/base_config.py", "snippet": "class InstantiateConfig(PrintableConfig):\n \"\"\"Config class for instantiating an the class specified in the _target attribute.\"\"\"\n\n _target: Type\n\n def setup(self, **kwargs) -> Any:\n \"\"\"Returns the instantiated object using the config.\"\"\"\n return self._target(self, **kwargs)" } ]

[ { "identifier": "ecgTransForm", "path": "models.py", "snippet": "class ecgTransForm(nn.Module):\r\n def __init__(self, configs, hparams):\r\n super(ecgTransForm, self).__init__()\r\n\r\n filter_sizes = [5, 9, 11]\r\n self.conv1 = nn.Conv1d(configs.input_channels, configs.mid_channels, kernel_size=filter_sizes[0],\r\n stride=configs.stride, bias=False, padding=(filter_sizes[0] // 2))\r\n self.conv2 = nn.Conv1d(configs.input_channels, configs.mid_channels, kernel_size=filter_sizes[1],\r\n stride=configs.stride, bias=False, padding=(filter_sizes[1] // 2))\r\n self.conv3 = nn.Conv1d(configs.input_channels, configs.mid_channels, kernel_size=filter_sizes[2],\r\n stride=configs.stride, bias=False, padding=(filter_sizes[2] // 2))\r\n\r\n self.bn = nn.BatchNorm1d(configs.mid_channels)\r\n self.relu = nn.ReLU()\r\n self.mp = nn.MaxPool1d(kernel_size=2, stride=2, padding=1)\r\n self.do = nn.Dropout(configs.dropout)\r\n\r\n\r\n self.conv_block2 = nn.Sequential(\r\n nn.Conv1d(configs.mid_channels, configs.mid_channels * 2, kernel_size=8, stride=1, bias=False, padding=4),\r\n nn.BatchNorm1d(configs.mid_channels * 2),\r\n nn.ReLU(),\r\n nn.MaxPool1d(kernel_size=2, stride=2, padding=1)\r\n )\r\n\r\n self.conv_block3 = nn.Sequential(\r\n nn.Conv1d(configs.mid_channels * 2, configs.final_out_channels, kernel_size=8, stride=1, bias=False,\r\n padding=4),\r\n nn.BatchNorm1d(configs.final_out_channels),\r\n nn.ReLU(),\r\n nn.MaxPool1d(kernel_size=2, stride=2, padding=1),\r\n )\r\n \r\n self.inplanes = 128\r\n self.crm = self._make_layer(SEBasicBlock, 128, 3)\r\n\r\n self.encoder_layer = nn.TransformerEncoderLayer(d_model=configs.trans_dim, nhead=configs.num_heads, batch_first=True)\r\n self.transformer_encoder = nn.TransformerEncoder(self.encoder_layer, num_layers=3)\r\n\r\n self.aap = nn.AdaptiveAvgPool1d(1)\r\n self.clf = nn.Linear(hparams[\"feature_dim\"], configs.num_classes)\r\n\r\n def _make_layer(self, block, planes, blocks, stride=1): # makes residual SE block\r\n downsample = None\r\n if stride != 1 or self.inplanes != planes * block.expansion:\r\n downsample = nn.Sequential(\r\n nn.Conv1d(self.inplanes, planes * block.expansion,\r\n kernel_size=1, stride=stride, bias=False),\r\n nn.BatchNorm1d(planes * block.expansion),\r\n )\r\n\r\n layers = []\r\n layers.append(block(self.inplanes, planes, stride, downsample))\r\n self.inplanes = planes * block.expansion\r\n for i in range(1, blocks):\r\n layers.append(block(self.inplanes, planes))\r\n\r\n return nn.Sequential(*layers)\r\n\r\n def forward(self, x_in):\r\n\r\n # Multi-scale Convolutions\r\n x1 = self.conv1(x_in)\r\n x2 = self.conv2(x_in)\r\n x3 = self.conv3(x_in)\r\n\r\n x_concat = torch.mean(torch.stack([x1, x2, x3],2), 2)\r\n x_concat = self.do(self.mp(self.relu(self.bn(x_concat))))\r\n\r\n x = self.conv_block2(x_concat)\r\n x = self.conv_block3(x)\r\n\r\n # Channel Recalibration Module\r\n x = self.crm(x)\r\n\r\n # Bi-directional Transformer\r\n x1 = self.transformer_encoder(x)\r\n x2 = self.transformer_encoder(torch.flip(x,[2]))\r\n x = x1+x2\r\n\r\n x = self.aap(x)\r\n x_flat = x.reshape(x.shape[0], -1)\r\n x_out = self.clf(x_flat)\r\n return x_out\r" }, { "identifier": "data_generator", "path": "dataloader.py", "snippet": "def data_generator(data_path, data_type, hparams):\r\n # original\r\n train_dataset = torch.load(os.path.join(data_path, data_type, f\"train.pt\"))\r\n val_dataset = torch.load(os.path.join(data_path, data_type, f\"val.pt\"))\r\n test_dataset = torch.load(os.path.join(data_path, data_type, f\"test.pt\"))\r\n\r\n # Loading datasets\r\n train_dataset = Load_Dataset(train_dataset)\r\n val_dataset = Load_Dataset(val_dataset)\r\n test_dataset = Load_Dataset(test_dataset)\r\n\r\n cw = train_dataset.y_data.numpy().tolist()\r\n cw_dict = {}\r\n for i in range(len(np.unique(train_dataset.y_data.numpy()))):\r\n cw_dict[i] = cw.count(i)\r\n # print(cw_dict)\r\n\r\n # Dataloaders\r\n batch_size = hparams[\"batch_size\"]\r\n train_loader = torch.utils.data.DataLoader(dataset=train_dataset, batch_size=batch_size,\r\n shuffle=True, drop_last=True, num_workers=0)\r\n val_loader = torch.utils.data.DataLoader(dataset=val_dataset, batch_size=batch_size,\r\n shuffle=False, drop_last=True, num_workers=0)\r\n test_loader = torch.utils.data.DataLoader(dataset=test_dataset, batch_size=batch_size,\r\n shuffle=False, drop_last=False, num_workers=0)\r\n return train_loader, val_loader, test_loader, cw_dict\r" }, { "identifier": "get_dataset_class", "path": "configs/data_configs.py", "snippet": "def get_dataset_class(dataset_name):\r\n \"\"\"Return the algorithm class with the given name.\"\"\"\r\n if dataset_name not in globals():\r\n raise NotImplementedError(\"Dataset not found: {}\".format(dataset_name))\r\n return globals()[dataset_name]\r" }, { "identifier": "get_hparams_class", "path": "configs/hparams.py", "snippet": "def get_hparams_class(dataset_name):\r\n \"\"\"Return the algorithm class with the given name.\"\"\"\r\n if dataset_name not in globals():\r\n raise NotImplementedError(\"Algorithm not found: {}\".format(dataset_name))\r\n return globals()[dataset_name]\r" }, { "identifier": "AverageMeter", "path": "utils.py", "snippet": "class AverageMeter(object):\r\n \"\"\"Computes and stores the average and current value\"\"\"\r\n\r\n def __init__(self):\r\n self.reset()\r\n\r\n def reset(self):\r\n self.val = 0\r\n self.avg = 0\r\n self.sum = 0\r\n self.count = 0\r\n\r\n def update(self, val, n=1):\r\n self.val = val\r\n self.sum += val * n\r\n self.count += n\r\n self.avg = self.sum / self.count\r" }, { "identifier": "to_device", "path": "utils.py", "snippet": "def to_device(input, device):\r\n if torch.is_tensor(input):\r\n return input.to(device=device)\r\n elif isinstance(input, str):\r\n return input\r\n elif isinstance(input, collections.Mapping):\r\n return {k: to_device(sample, device=device) for k, sample in input.items()}\r\n elif isinstance(input, collections.Sequence):\r\n return [to_device(sample, device=device) for sample in input]\r\n else:\r\n raise TypeError(\"Input must contain tensor, dict or list, found {type(input)}\")\r" }, { "identifier": "_save_metrics", "path": "utils.py", "snippet": "def _save_metrics(pred_labels, true_labels, log_dir, home_path, classes_names):\r\n pred_labels = np.array(pred_labels).astype(int)\r\n true_labels = np.array(true_labels).astype(int)\r\n\r\n r = classification_report(true_labels, pred_labels, digits=6, output_dict=True)\r\n\r\n df = pd.DataFrame(r)\r\n accuracy = accuracy_score(true_labels, pred_labels)\r\n df[\"accuracy\"] = accuracy\r\n df = df * 100\r\n\r\n # save classification report\r\n file_name = \"classification_report.xlsx\"\r\n report_Save_path = os.path.join(home_path, log_dir, file_name)\r\n df.to_excel(report_Save_path)\r" }, { "identifier": "copy_Files", "path": "utils.py", "snippet": "def copy_Files(destination):\r\n destination_dir = os.path.join(destination, \"MODEL_BACKUP_FILES\")\r\n os.makedirs(destination_dir, exist_ok=True)\r\n copy(\"main.py\", os.path.join(destination_dir, \"main.py\"))\r\n copy(\"dataloader.py\", os.path.join(destination_dir, \"dataloader.py\"))\r\n copy(f\"models.py\", os.path.join(destination_dir, f\"models.py\"))\r\n copy(f\"configs/data_configs.py\", os.path.join(destination_dir, f\"data_configs.py\"))\r\n copy(f\"configs/hparams.py\", os.path.join(destination_dir, f\"hparams.py\"))\r\n copy(f\"trainer.py\", os.path.join(destination_dir, f\"trainer.py\"))\r\n copy(\"utils.py\", os.path.join(destination_dir, \"utils.py\"))\r" }, { "identifier": "_plot_umap", "path": "utils.py", "snippet": "def _plot_umap(model, data_loader, device, save_dir):\r\n import umap\r\n import umap.plot\r\n from matplotlib.colors import ListedColormap\r\n classes_names = ['N','S','V','F','Q']\r\n \r\n font = {'family' : 'Times New Roman',\r\n 'weight' : 'bold',\r\n 'size' : 17}\r\n plt.rc('font', **font)\r\n \r\n with torch.no_grad():\r\n # Source flow\r\n data = data_loader.dataset.x_data.float().to(device)\r\n labels = data_loader.dataset.y_data.view((-1)).long()\r\n out = model[0](data)\r\n features = model[1](out)\r\n\r\n\r\n if not os.path.exists(os.path.join(save_dir, \"umap_plots\")):\r\n os.mkdir(os.path.join(save_dir, \"umap_plots\"))\r\n \r\n #cmaps = plt.get_cmap('jet')\r\n model_reducer = umap.UMAP() #n_neighbors=3, min_dist=0.3, metric='correlation', random_state=42)\r\n embedding = model_reducer.fit_transform(features.detach().cpu().numpy())\r\n \r\n # Normalize the labels to [0, 1] for colormap\r\n norm_labels = labels / 4.0\r\n \r\n\r\n # Create a new colormap by extracting the first 5 colors from \"Paired\"\r\n paired = plt.cm.get_cmap('Paired', 12) # 12 distinct colors\r\n new_colors = [paired(0), paired(1), paired(2), paired(4), paired(6)] # Skip every second color, but take both from the first pair\r\n new_cmap = ListedColormap(new_colors)\r\n\r\n print(\"Plotting UMAP ...\")\r\n plt.figure(figsize=(16, 10))\r\n # scatter = plt.scatter(embedding[:, 0], embedding[:, 1], c=labels, s=10, cmap='Spectral')\r\n scatter = plt.scatter(embedding[:, 0], embedding[:, 1], c=norm_labels, cmap=new_cmap, s=15)\r\n\r\n handles, _ = scatter.legend_elements(prop='colors')\r\n plt.legend(handles, classes_names, title=\"Classes\")\r\n file_name = \"umap_.png\"\r\n fig_save_name = os.path.join(save_dir, \"umap_plots\", file_name)\r\n plt.xticks([])\r\n plt.yticks([])\r\n plt.savefig(fig_save_name, bbox_inches='tight')\r\n plt.close()\r" }, { "identifier": "fix_randomness", "path": "utils.py", "snippet": "def fix_randomness(SEED):\r\n random.seed(SEED)\r\n np.random.seed(SEED)\r\n torch.manual_seed(SEED)\r\n torch.cuda.manual_seed(SEED)\r\n torch.backends.cudnn.deterministic = True\r\n torch.backends.cudnn.benchmark = False\r" }, { "identifier": "starting_logs", "path": "utils.py", "snippet": "def starting_logs(data_type, exp_log_dir, seed_id):\r\n log_dir = os.path.join(exp_log_dir, \"_seed_\" + str(seed_id))\r\n os.makedirs(log_dir, exist_ok=True)\r\n log_file_name = os.path.join(log_dir, f\"logs_{datetime.now().strftime('%d_%m_%Y_%H_%M_%S')}.log\")\r\n logger = _logger(log_file_name)\r\n logger.debug(\"=\" * 45)\r\n logger.debug(f'Dataset: {data_type}')\r\n logger.debug(\"=\" * 45)\r\n logger.debug(f'Seed: {seed_id}')\r\n logger.debug(\"=\" * 45)\r\n return logger, log_dir\r" }, { "identifier": "save_checkpoint", "path": "utils.py", "snippet": "def save_checkpoint(home_path, model, dataset, dataset_configs, log_dir, hparams):\r\n save_dict = {\r\n \"dataset\": dataset,\r\n \"configs\": dataset_configs.__dict__,\r\n \"hparams\": dict(hparams),\r\n \"model\": model[0].state_dict(),\r\n \"clf\": model[1].state_dict()\r\n }\r\n # save classification report\r\n save_path = os.path.join(home_path, log_dir, \"checkpoint.pt\")\r\n\r\n torch.save(save_dict, save_path)\r" }, { "identifier": "_calc_metrics", "path": "utils.py", "snippet": "def _calc_metrics(pred_labels, true_labels, classes_names):\r\n pred_labels = np.array(pred_labels).astype(int)\r\n true_labels = np.array(true_labels).astype(int)\r\n\r\n r = classification_report(true_labels, pred_labels, target_names=classes_names, digits=6, output_dict=True)\r\n accuracy = accuracy_score(true_labels, pred_labels)\r\n\r\n return accuracy * 100, r[\"macro avg\"][\"f1-score\"] * 100\r" } ]

[ { "identifier": "get_plotly_embedding", "path": "visualize_app/visualize_embedding.py", "snippet": "def get_plotly_embedding(\n df: pd.DataFrame = None,\n opacity: float = 0.2,\n **kwargs,\n) -> go.Figure:\n \"\"\"\n Plot the embedding of a dataframe with plotly.\n\n Args:\n df: dataframe with columns x, y, z, smact_allowed, mp_data.\n opacity: opacity of the markers. Default is 0.8.\n kwargs: additional keyword arguments.\n Returns:\n fig: plotly figure object.\n \"\"\"\n # check if the dataframe is empty\n if df is None:\n return go.Figure()\n\n fig = px.scatter_3d(\n df,\n x=\"x\",\n y=\"y\",\n z=\"z\",\n template=\"plotly_white\",\n color=\"label\",\n color_discrete_map={\n \"0\": \"#D9D9D9\",\n \"1\": \"rgba(34, 224, 0, 0.8)\",\n \"2\": \"rgba(255, 18, 1, 0.8)\",\n \"3\": \"rgba(0, 47, 255, 0.8)\",\n # \"0\": px.colors.qualitative.Vivid[-1], # \"#D9D9D9\"\n # \"1\": px.colors.qualitative.Vivid[0], # \"#22E000\",\n # \"2\": px.colors.qualitative.Vivid[1], # \"#FF1201\",\n # \"3\": px.colors.qualitative.Vivid[2], # \"#002FFF\",\n },\n opacity=opacity,\n hover_data=[\n \"formula\",\n ],\n )\n\n # update hovertemplate\n fig.update_traces(\n hovertemplate=\"<br>\".join(\n [\n \"formula: %{customdata[0]}\",\n ]\n )\n )\n\n # remove the background grid and axes and ticks and tick labels\n fig.update_layout(\n scene=dict(\n xaxis=dict(\n showticklabels=False,\n title=\"\",\n ),\n yaxis=dict(\n showticklabels=False,\n title=\"\",\n ),\n zaxis=dict(\n showticklabels=False,\n title=\"\",\n ),\n ),\n )\n\n # set title\n if \"title\" in kwargs:\n fig.update_layout(\n title=dict(\n text=kwargs[\"title\"],\n font=dict(size=20),\n x=0.5,\n y=0.95,\n xanchor=\"center\",\n yanchor=\"top\",\n )\n )\n\n # update the legend labels\n legend_label_map = {\n \"0\": \"Unlikely (False, False)\",\n \"1\": \"Interesting (False, True)\",\n \"2\": \"Missing (True, False)\",\n \"3\": \"Standard (True, True)\",\n }\n\n for trace in fig.data:\n trace.name = legend_label_map[trace.name]\n\n # update the marker\n\n fig.update_traces(\n marker=dict(\n size=5,\n # line=dict(width=0.5, color=\"Grey\"),\n ),\n selector=dict(mode=\"markers\"),\n )\n\n # update the legend title\n fig.update_layout(\n legend_title_text=\" click legend 👆 <br>(smact_allowed, mp_data)\",\n )\n return fig" }, { "identifier": "get_plotly_structure", "path": "visualize_app/visualize_structure.py", "snippet": "def get_plotly_structure(structure: Structure = None) -> go.Figure:\n \"\"\"\n Plot a pymatgen structure with its unit cell using plotly.\n Args:\n structure: pymatgen structure object.\n kwargs: additional keyword arguments.\n Returns:\n fig: plotly figure object.\n \"\"\"\n if structure is None:\n return px.scatter_3d()\n\n # Getting atomic positions and species using list comprehension\n positions = [site.coords for site in structure]\n species = [str(site.specie) for site in structure]\n\n # Getting atomic colors\n atomic_colors = [jmol_colors[Element(specie).Z] for specie in species]\n\n # Getting atomic radii\n # atomic_radii = [float(Element(specie).atomic_radius) for specie in species]\n\n # Extracting x, y, and z coordinates\n x, y, z = zip(*positions)\n\n # Getting lattice vectors\n a, b, c = structure.lattice.matrix\n\n # Define lines for the unit cell\n lines = [\n [[0, 0, 0], a],\n [[0, 0, 0], b],\n [[0, 0, 0], c],\n [a, a + b],\n [a, a + c],\n [b, b + a],\n [b, b + c],\n [c, c + a],\n [c, c + b],\n [a + b, a + b + c],\n [a + c, a + c + b],\n [b + c, b + c + a],\n ]\n\n # scatter atoms\n trace_atoms = go.Scatter3d(\n x=x,\n y=y,\n z=z,\n mode=\"markers\",\n text=species,\n hoverinfo=\"text\",\n marker=dict(\n symbol=\"circle\",\n sizemode=\"diameter\",\n color=atomic_colors,\n # size=[20 * r for r in atomic_radii],\n size=20,\n line=dict(color=\"black\", width=5),\n ),\n )\n\n # draw unit cell\n trace_lines = []\n for line in lines:\n x_values, y_values, z_values = zip(*line)\n trace_lines.append(\n go.Scatter3d(\n x=x_values,\n y=y_values,\n z=z_values,\n mode=\"lines\",\n line=dict(color=\"black\"),\n )\n )\n\n # remove the background grid\n layout = go.Layout(\n scene=dict(\n xaxis=dict(\n showticklabels=False,\n title=\"\",\n showgrid=False,\n zeroline=False,\n showline=False,\n visible=False,\n ),\n yaxis=dict(\n showticklabels=False,\n title=\"\",\n showgrid=False,\n zeroline=False,\n showline=False,\n visible=False,\n ),\n zaxis=dict(\n showticklabels=False,\n title=\"\",\n showgrid=False,\n zeroline=False,\n showline=False,\n visible=False,\n ),\n ),\n showlegend=False,\n )\n\n fig = go.Figure(data=[trace_atoms, *trace_lines], layout=layout)\n return fig" }, { "identifier": "fn_chemical_check", "path": "visualize_app/utils.py", "snippet": "def fn_chemical_check(\n df_embedding: pd.DataFrame, species_1: str, species_2: str\n) -> np.array:\n \"\"\"\n Check if the chemical system contains the specified species.\n\n Args:\n df_embedding (pd.DataFrame): Embedding dataframe.\n species_1 (str): Chemical species 1.\n species_2 (str): Chemical species 2.\n\n Returns:\n np.array: Boolean array for the chemical systems that contain the specified species.\n \"\"\"\n\n chemicals = np.array(df_embedding.index)\n\n # regular expression patterns\n pattern_1 = r\"{}(?:(?={})|(?![a-zA-Z]))\".format(species_1, species_2)\n pattern_2 = r\"{}(?:(?={})|(?![a-zA-Z]))\".format(species_2, species_1)\n # get the mask\n mask = np.array(\n [\n True\n if re.search(pattern_1, chemical)\n and re.search(pattern_2, chemical)\n else True\n if re.search(pattern_1, chemical) and species_2 == \"default\"\n else True\n if re.search(pattern_2, chemical) and species_1 == \"default\"\n else True\n if species_1 == \"default\" and species_2 == \"default\"\n else False\n for chemical in chemicals\n ]\n )\n\n return mask" }, { "identifier": "blank_fig", "path": "visualize_app/utils.py", "snippet": "def blank_fig():\n fig = go.Figure(go.Scatter(x=[], y=[]))\n fig.update_layout(template=None)\n fig.update_xaxes(showgrid=False, showticklabels=False, zeroline=False)\n fig.update_yaxes(showgrid=False, showticklabels=False, zeroline=False)\n\n return fig" } ]

[ { "identifier": "Agent", "path": "serl/agents/agent.py", "snippet": "class Agent(struct.PyTreeNode):\n actor: TrainState\n rng: PRNGKey\n\n def eval_actions(self, observations: np.ndarray) -> np.ndarray:\n actions = _eval_actions(self.actor.apply_fn, self.actor.params, observations)\n return np.asarray(actions)\n\n def sample_actions(self, observations: np.ndarray) -> np.ndarray:\n actions, new_rng = _sample_actions(\n self.rng, self.actor.apply_fn, self.actor.params, observations\n )\n return np.asarray(actions), self.replace(rng=new_rng)" }, { "identifier": "Temperature", "path": "serl/agents/sac/temperature.py", "snippet": "class Temperature(nn.Module):\n initial_temperature: float = 1.0\n\n @nn.compact\n def __call__(self) -> jnp.ndarray:\n log_temp = self.param(\n \"log_temp\",\n init_fn=lambda key: jnp.full((), jnp.log(self.initial_temperature)),\n )\n return jnp.exp(log_temp)" }, { "identifier": "DatasetDict", "path": "serl/data/dataset.py", "snippet": "def _check_lengths(dataset_dict: DatasetDict, dataset_len: Optional[int] = None) -> int:\ndef _subselect(dataset_dict: DatasetDict, index: np.ndarray) -> DatasetDict:\ndef _sample(\n dataset_dict: Union[np.ndarray, DatasetDict], indx: np.ndarray\n) -> DatasetDict:\n def __init__(self, dataset_dict: DatasetDict, seed: Optional[int] = None):\n def np_random(self) -> np.random.RandomState:\n def seed(self, seed: Optional[int] = None) -> list:\n def __len__(self) -> int:\n def sample(\n self,\n batch_size: int,\n keys: Optional[Iterable[str]] = None,\n indx: Optional[np.ndarray] = None,\n ) -> frozen_dict.FrozenDict:\n def sample_jax(self, batch_size: int, keys: Optional[Iterable[str]] = None):\n def _sample_jax(rng, src, max_indx: int):\n def split(self, ratio: float) -> Tuple[\"Dataset\", \"Dataset\"]:\n def _trajectory_boundaries_and_returns(self) -> Tuple[list, list, list]:\n def filter(\n self, take_top: Optional[float] = None, threshold: Optional[float] = None\n ):\n def normalize_returns(self, scaling: float = 1000):\nclass Dataset(object):" }, { "identifier": "TanhNormal", "path": "serl/distributions/tanh_normal.py", "snippet": "class Normal(nn.Module):\n def __call__(self, inputs, *args, **kwargs) -> tfd.Distribution:" }, { "identifier": "Ensemble", "path": "serl/networks/ensemble.py", "snippet": "class Ensemble(nn.Module):\n net_cls: Type[nn.Module]\n num: int = 2\n\n @nn.compact\n def __call__(self, *args):\n ensemble = nn.vmap(\n self.net_cls,\n variable_axes={\"params\": 0},\n split_rngs={\"params\": True, \"dropout\": True},\n in_axes=None,\n out_axes=0,\n axis_size=self.num,\n )\n return ensemble()(*args)" }, { "identifier": "subsample_ensemble", "path": "serl/networks/ensemble.py", "snippet": "def subsample_ensemble(key: jax.random.PRNGKey, params, num_sample: int, num_qs: int):\n if num_sample is not None:\n all_indx = jnp.arange(0, num_qs)\n indx = jax.random.choice(key, a=all_indx, shape=(num_sample,), replace=False)\n\n if \"Ensemble_0\" in params:\n ens_params = jax.tree_util.tree_map(\n lambda param: param[indx], params[\"Ensemble_0\"]\n )\n params = params.copy(add_or_replace={\"Ensemble_0\": ens_params})\n else:\n params = jax.tree_util.tree_map(lambda param: param[indx], params)\n return params" }, { "identifier": "MLP", "path": "serl/networks/mlp.py", "snippet": "class MLP(nn.Module):\n hidden_dims: Sequence[int]\n activations: Callable[[jnp.ndarray], jnp.ndarray] = nn.relu\n activate_final: bool = False\n use_layer_norm: bool = False\n scale_final: Optional[float] = None\n dropout_rate: Optional[float] = None\n spectral_norm: bool = False\n\n @nn.compact\n def __call__(self, x: jnp.ndarray, training: bool = False) -> jnp.ndarray:\n\n for i, size in enumerate(self.hidden_dims):\n if i + 1 == len(self.hidden_dims) and self.scale_final is not None:\n x = nn.Dense(size, kernel_init=default_init(self.scale_final))(x)\n else:\n x = nn.Dense(size, kernel_init=default_init())(x)\n\n if i + 1 < len(self.hidden_dims) or self.activate_final:\n if self.dropout_rate is not None and self.dropout_rate > 0:\n x = nn.Dropout(rate=self.dropout_rate)(\n x, deterministic=not training\n )\n if self.use_layer_norm:\n x = nn.LayerNorm()(x)\n x = self.activations(x)\n return x" }, { "identifier": "StateActionValue", "path": "serl/networks/state_action_value.py", "snippet": "class StateActionValue(nn.Module):\n base_cls: nn.Module\n\n @nn.compact\n def __call__(\n self, observations: jnp.ndarray, actions: jnp.ndarray, *args, **kwargs\n ) -> jnp.ndarray:\n inputs = jnp.concatenate([observations, actions], axis=-1)\n outputs = self.base_cls()(inputs, *args, **kwargs)\n\n value = nn.Dense(1, kernel_init=default_init())(outputs)\n\n return jnp.squeeze(value, -1)" } ]

[ { "identifier": "BotConfig", "path": "server/config.py", "snippet": "class BotConfig:\n _openai_api_key: str = None\n _openai_model_name: str = None\n _log_dir_path: str = None\n _daily_room_url: str = None\n _daily_meeting_token: str = None\n\n def __init__(self,\n openai_api_key: str,\n openai_model_name: str,\n daily_room_url: str = None,\n daily_meeting_token: str = None,\n log_dir_path: str = None):\n self._openai_api_key = openai_api_key\n self._openai_model_name = openai_model_name\n self._log_dir_path = log_dir_path\n self._daily_room_url = daily_room_url\n self._daily_meeting_token = daily_meeting_token\n\n @property\n def openai_model_name(self) -> str:\n return self._openai_model_name\n\n @property\n def openai_api_key(self) -> str:\n return self._openai_api_key\n\n @property\n def log_dir_path(self) -> str:\n return self._log_dir_path\n\n @property\n def daily_room_url(self) -> str:\n return self._daily_room_url\n\n @property\n def daily_meeting_token(self) -> str:\n return self._daily_meeting_token\n\n def get_log_file_path(self, room_name: str) -> str | None:\n \"\"\"Returns the log file for the given room name\"\"\"\n if not self.log_dir_path:\n return None\n return os.path.join(self.log_dir_path, f\"{room_name}.log\")\n\n def ensure_dirs(self):\n \"\"\"Creates required file directories if they do not already exist.\"\"\"\n if self.log_dir_path:\n ensure_dir(self.log_dir_path)" }, { "identifier": "Session", "path": "server/call/session.py", "snippet": "class Session(EventHandler):\n \"\"\"Class representing a single meeting happening within a Daily room.\"\"\"\n\n _config: BotConfig\n _assistant: Assistant\n _summary: Summary | None\n\n # Daily-related properties\n _id: str | None\n _call_client: CallClient | None\n _room: Room\n\n # Shutdown-related properties\n _is_destroyed: bool\n _shutdown_timer: threading.Timer | None = None\n\n def __init__(self, config: BotConfig):\n super().__init__()\n self._is_destroyed = False\n self._config = config\n self._summary = None\n self._id = None\n self._room = self._get_room_config(self._config.daily_room_url)\n self._logger = self.create_logger(self._room.name)\n self._assistant = OpenAIAssistant(\n config.openai_api_key,\n config.openai_model_name,\n self._logger)\n self._logger.info(\"Initialized session %s\", self._room.name)\n\n def start(self):\n # Start session on new thread\n task = threading.Thread(target=self._run)\n task.start()\n while not self.is_destroyed:\n time.sleep(1)\n\n @property\n def room_url(self) -> str:\n return self._room.url\n\n @property\n def id(self) -> str:\n return self._id\n\n @property\n def is_destroyed(self) -> bool:\n return self._is_destroyed\n\n def _get_room_config(self, room_url: str = None) -> Room:\n \"\"\"Creates a Daily room and uses it to start a session\"\"\"\n parsed_url = urlparse(room_url)\n room_name = os.path.basename(parsed_url.path)\n token = self._config.daily_meeting_token\n room = Room(url=room_url, name=room_name, token=token)\n return room\n\n def _run(self):\n \"\"\"Waits for at least one person to join the associated Daily room,\n then joins, starts transcription, and begins registering context.\"\"\"\n call_client = CallClient(event_handler=self)\n self._call_client = call_client\n room = self._room\n self._logger.info(\"Joining Daily room %s\", room.url)\n call_client.join(\n room.url,\n room.token,\n completion=self.on_joined_meeting)\n\n async def _generate_clean_transcript(self) -> bool:\n \"\"\"Generates a clean transcript from the raw context.\"\"\"\n if self._is_destroyed:\n return True\n try:\n await self._assistant.cleanup_transcript()\n except Exception as e:\n self._logger.warning(\n \"Failed to generate clean transcript: %s\", e)\n return False\n\n async def _query_assistant(self, custom_query: str = None) -> Future[str]:\n \"\"\"Queries the configured assistant with either the given query, or the\n configured assistant's default\"\"\"\n\n want_cached_summary = not bool(custom_query)\n answer = None\n\n # If we want a generic summary, and we have a cached one that's less than 15 seconds old,\n # just return that.\n if want_cached_summary and self._summary:\n seconds_since_generation = time.time() - self._summary.retrieved_at\n if seconds_since_generation < 15:\n self._logger.info(\"Returning cached summary\")\n answer = self._summary.content\n\n # If we don't have a cached summary, or it's too old, query the\n # assistant.\n if not answer:\n self._logger.info(\"Querying assistant\")\n try:\n answer = await self._assistant.query(custom_query)\n # If there was no custom query provided, save this as cached\n # summary.\n if want_cached_summary:\n self._logger.info(\"Saving general summary\")\n self._summary = Summary(\n content=answer, retrieved_at=time.time())\n except NoContextError:\n answer = (\"I don't have any context saved yet. Please speak to add some context or \"\n \"confirm that transcription is enabled.\")\n except Exception as e:\n self._logger.error(\n \"Failed to query assistant: %s\", e)\n answer = (\"Something went wrong while generating the summary. Please check the server logs.\")\n\n return answer\n\n def on_app_message_sent(self, _, error: str = None):\n \"\"\"Callback invoked when an app message is sent.\"\"\"\n if error:\n self._logger.error(\"Failed to send app message: %s\", error)\n\n def on_app_message(self,\n message: str,\n sender: str):\n \"\"\"Callback invoked when a Daily app message is received.\"\"\"\n # TODO message appears to be a dict when our docs say str.\n # For now dumping it to a JSON string and parsing it back out,\n # until designed behavior is clarified.\n jsonMsg = json.dumps(message)\n data = json.loads(jsonMsg)\n kind = data.get(\"kind\")\n if kind != \"assist\":\n return\n\n query = data.get(\"query\")\n\n recipient = sender\n\n # If this is a broadcast, set recipient to all participants\n if bool(data.get(\"broadcast\")):\n recipient = None\n\n task = data.get(\"task\")\n\n answer: str = None\n if task == \"summary\" or task == \"query\":\n answer = asyncio.run(self._query_assistant(query))\n elif task == \"transcript\":\n answer = self._assistant.get_clean_transcript()\n\n self._call_client.send_app_message({\n \"kind\": f\"ai-{task}\",\n \"data\": answer\n }, participant=recipient, completion=self.on_app_message_sent)\n\n def on_left_meeting(self, _, error: str = None):\n \"\"\"Cancels any ongoing shutdown timer and marks this session as destroyed\"\"\"\n if error:\n self._logger.error(\n \"Encountered error while leaving meeting: %s\", error)\n\n # There's a chance of a shutdown timer being ongoing at the time the bot\n # is kicked or leaves for other reasons. Clean up the shutdown timer if\n # that is the case.\n if self._shutdown_timer:\n self._logger.info(\n \"Participant left meeting - cancelling shutdown.\")\n self.cancel_shutdown_timer()\n\n # Similar to above, if this session has already been destroyed for any other reason,\n # Don't do this again.\n if self._is_destroyed:\n self._logger.info(\"Session %s already destroyed.\", self._room.url)\n return\n\n self._logger.info(\"Left meeting %s\", self._room.url)\n self._assistant.destroy()\n self._is_destroyed = True\n\n def on_joined_meeting(self, join_data, error):\n \"\"\"Callback invoked when the bot has joined the Daily room.\"\"\"\n if error:\n raise Exception(\"failed to join meeting\", error)\n self._logger.info(\"Bot joined meeting %s\", self._room.url)\n self._id = join_data[\"participants\"][\"local\"][\"id\"]\n\n # TODO (Liza): Remove this when transcription started events are invoked\n # as expected\n threading.Thread(\n target=self.start_transcript_polling,\n daemon=True).start()\n\n self._call_client.set_user_name(\"Daily AI Assistant\")\n\n # Check whether the bot is actually the only one in the call, in which case\n # the shutdown timer should start. The shutdown will be cancelled if\n # daily-python detects someone new joining.\n self.maybe_start_shutdown()\n\n def on_error(self, message):\n \"\"\"Callback invoked when an error is received.\"\"\"\n self._logger.error(\"Received meeting error: %s\", message)\n\n async def poll_async_func(self, async_func, interval):\n while True:\n await async_func()\n if self._is_destroyed:\n return\n await asyncio.sleep(interval)\n\n def start_transcript_polling(self):\n \"\"\"Starts an asyncio event loop and schedules generate_clean_transcript to run every 15 seconds.\"\"\"\n loop = asyncio.new_event_loop()\n asyncio.set_event_loop(loop)\n loop.run_until_complete(\n self.poll_async_func(\n self._generate_clean_transcript, 15))\n\n # TODO: (Liza) Uncomment this when transcription events are properly invoked\n # if the transcription is starte before the bot joins.\n # def on_transcription_started(self, status):\n # self._logger.info(\"Transcription started: %s\", status)\n # threading.Thread(target=self.start_transcript_polling, daemon=True).start()\n\n def on_transcription_stopped(self, stopped_by: str, stopped_by_error: str):\n self._logger.info(\n \"Transcription stopped: %s (%s)\",\n stopped_by,\n stopped_by_error)\n\n def on_transcription_error(self, message):\n \"\"\"Callback invoked when a transcription error is received.\"\"\"\n self._logger.error(\"Received transcription error: %s\", message)\n\n def on_transcription_message(self, message):\n \"\"\"Callback invoked when a transcription message is received.\"\"\"\n user_name = message[\"user_name\"]\n text = message[\"text\"]\n timestamp = datetime.now().strftime('%Y-%m-%d %H:%M:%S.%f')\n metadata = [user_name, 'voice', timestamp]\n self._assistant.register_new_context(text, metadata)\n\n def on_participant_joined(self, participant):\n # As soon as someone joins, stop shutdown process if one is in progress\n if self._shutdown_timer:\n self._logger.info(\"Participant joined - cancelling shutdown.\")\n self.cancel_shutdown_timer()\n\n def on_participant_left(self,\n participant,\n reason):\n \"\"\"Callback invoked when a participant leaves the Daily room.\"\"\"\n self.maybe_start_shutdown()\n\n def on_call_state_updated(self, state: Mapping[str, Any]) -> None:\n \"\"\"Invoked when the Daily call state has changed\"\"\"\n self._logger.info(\n \"Call state updated for session %s: %s\",\n self._room.url,\n state)\n if state == \"left\" and not self._is_destroyed:\n self._logger.info(\"Call state left, destroying immediately\")\n self.on_left_meeting(None)\n\n def maybe_start_shutdown(self) -> bool:\n \"\"\"Checks if the session should be shut down, and if so, starts the shutdown process.\"\"\"\n count = self._call_client.participant_counts()['present']\n self._logger.info(\n \"Participant count: %s\", count)\n\n # If there is at least one present participant, do nothing.\n if count > 1:\n return False\n\n self._logger.info(\"Starting shutdown timer\")\n\n # If there are no present participants left, wait 1 minute and\n # start shutdown.\n self._shutdown_timer = threading.Timer(60.0, self.shutdown)\n self._shutdown_timer.start()\n return True\n\n def shutdown(self):\n \"\"\"Shuts down the session, leaving the Daily room, invoking the shutdown callback,\n and cancelling any pending Futures\"\"\"\n self._logger.info(\n f\"Session {self._id} shutting down. Active threads: %s\",\n threading.active_count())\n\n self.cancel_shutdown_timer()\n self._call_client.leave(self.on_left_meeting)\n\n def cancel_shutdown_timer(self):\n \"\"\"Cancels the live shutdown timer\"\"\"\n if self._shutdown_timer:\n self._shutdown_timer.cancel()\n self._shutdown_timer = None\n\n def create_logger(self, name) -> Logger:\n \"\"\"Creates a logger for this session\"\"\"\n logger = logging.getLogger(name)\n logger.setLevel(logging.DEBUG)\n\n formatter = logging.Formatter(\n '%(asctime)s -[%(threadName)s-%(thread)s] - %(levelname)s - %(message)s')\n\n log_file_path = self._config.get_log_file_path(self._room.name)\n if log_file_path:\n file_handler = logging.FileHandler(\n self._config.get_log_file_path(self._room.name))\n file_handler.setFormatter(formatter)\n logger.addHandler(file_handler)\n else:\n stream_handler = logging.StreamHandler(sys.stdout)\n stream_handler.setFormatter(formatter)\n logger.addHandler(stream_handler)\n\n return logger" } ]

[ { "identifier": "add_gfilter", "path": "database/gfilters_mdb.py", "snippet": "async def add_gfilter(gfilters, text, reply_text, btn, file, alert):\n mycol = mydb[str(gfilters)]\n # mycol.create_index([('text', 'text')])\n\n data = {\n 'text':str(text),\n 'reply':str(reply_text),\n 'btn':str(btn),\n 'file':str(file),\n 'alert':str(alert)\n }\n\n try:\n mycol.update_one({'text': str(text)}, {\"$set\": data}, upsert=True)\n except:\n logger.exception('Some error occured!', exc_info=True)" }, { "identifier": "get_gfilters", "path": "database/gfilters_mdb.py", "snippet": "async def get_gfilters(gfilters):\n mycol = mydb[str(gfilters)]\n\n texts = []\n query = mycol.find()\n try:\n for file in query:\n text = file['text']\n texts.append(text)\n except:\n pass\n return texts" }, { "identifier": "delete_gfilter", "path": "database/gfilters_mdb.py", "snippet": "async def delete_gfilter(message, text, gfilters):\n mycol = mydb[str(gfilters)]\n \n myquery = {'text':text }\n query = mycol.count_documents(myquery)\n if query == 1:\n mycol.delete_one(myquery)\n await message.reply_text(\n f\"'`{text}`' deleted. I'll not respond to that gfilter anymore.\",\n quote=True,\n parse_mode=enums.ParseMode.MARKDOWN\n )\n else:\n await message.reply_text(\"Couldn't find that gfilter!\", quote=True)" }, { "identifier": "count_gfilters", "path": "database/gfilters_mdb.py", "snippet": "async def count_gfilters(gfilters):\n mycol = mydb[str(gfilters)]\n\n count = mycol.count()\n return False if count == 0 else count" }, { "identifier": "active_connection", "path": "database/connections_mdb.py", "snippet": "async def active_connection(user_id):\n\n query = mycol.find_one(\n { \"_id\": user_id },\n { \"_id\": 0, \"group_details\": 0 }\n )\n if not query:\n return None\n\n group_id = query['active_group']\n return int(group_id) if group_id != None else None" }, { "identifier": "get_file_id", "path": "utils.py", "snippet": "def get_file_id(msg: Message):\n if msg.media:\n for message_type in (\n \"photo\",\n \"animation\",\n \"audio\",\n \"document\",\n \"video\",\n \"video_note\",\n \"voice\",\n \"sticker\"\n ):\n obj = getattr(msg, message_type)\n if obj:\n setattr(obj, \"message_type\", message_type)\n return obj" }, { "identifier": "gfilterparser", "path": "utils.py", "snippet": "def gfilterparser(text, keyword):\n if \"buttonalert\" in text:\n text = (text.replace(\"\\n\", \"\\\\n\").replace(\"\\t\", \"\\\\t\"))\n buttons = []\n note_data = \"\"\n prev = 0\n i = 0\n alerts = []\n for match in BTN_URL_REGEX.finditer(text):\n # Check if btnurl is escaped\n n_escapes = 0\n to_check = match.start(1) - 1\n while to_check > 0 and text[to_check] == \"\\\\\":\n n_escapes += 1\n to_check -= 1\n\n # if even, not escaped -> create button\n if n_escapes % 2 == 0:\n note_data += text[prev:match.start(1)]\n prev = match.end(1)\n if match.group(3) == \"buttonalert\":\n # create a thruple with button label, url, and newline status\n if bool(match.group(5)) and buttons:\n buttons[-1].append(InlineKeyboardButton(\n text=match.group(2),\n callback_data=f\"gfilteralert:{i}:{keyword}\"\n ))\n else:\n buttons.append([InlineKeyboardButton(\n text=match.group(2),\n callback_data=f\"gfilteralert:{i}:{keyword}\"\n )])\n i += 1\n alerts.append(match.group(4))\n elif bool(match.group(5)) and buttons:\n buttons[-1].append(InlineKeyboardButton(\n text=match.group(2),\n url=match.group(4).replace(\" \", \"\")\n ))\n else:\n buttons.append([InlineKeyboardButton(\n text=match.group(2),\n url=match.group(4).replace(\" \", \"\")\n )])\n\n else:\n note_data += text[prev:to_check]\n prev = match.start(1) - 1\n else:\n note_data += text[prev:]\n\n try:\n return note_data, buttons, alerts\n except:\n return note_data, buttons, None" }, { "identifier": "split_quotes", "path": "utils.py", "snippet": "def split_quotes(text: str) -> List:\n if not any(text.startswith(char) for char in START_CHAR):\n return text.split(None, 1)\n counter = 1 # ignore first char -> is some kind of quote\n while counter < len(text):\n if text[counter] == \"\\\\\":\n counter += 1\n elif text[counter] == text[0] or (text[0] == SMART_OPEN and text[counter] == SMART_CLOSE):\n break\n counter += 1\n else:\n return text.split(None, 1)\n\n # 1 to avoid starting quote, and counter is exclusive so avoids ending\n key = remove_escapes(text[1:counter].strip())\n # index will be in range, or `else` would have been executed and returned\n rest = text[counter + 1:].strip()\n if not key:\n key = text[0] + text[0]\n return list(filter(None, [key, rest]))" }, { "identifier": "ADMINS", "path": "info.py", "snippet": "ADMINS = [int(admin) if id_pattern.search(admin) else admin for admin in environ.get('ADMINS', '').split()]" } ]

[ { "identifier": "torch_dtype", "path": "RotatedMNIST/LPS/emlp-pytorch/emlp_pytorch/reps/utils.py", "snippet": "def torch_dtype(dtype):\n \"\"\" Convert a string representation of a torch dtype to the actual\n torch dtype. \"\"\"\n if isinstance(dtype, torch.dtype):\n return dtype\n if dtype in _TORCH_DTYPES:\n return _TORCH_DTYPES[dtype]\n return torch.empty(0).to(dtype).dtype" }, { "identifier": "dtype_cast", "path": "RotatedMNIST/LPS/emlp-pytorch/emlp_pytorch/reps/utils.py", "snippet": "def dtype_cast(A, B):\n \"\"\" Casts A and B to the same dtype, preferring complex dtypes over real dtypes. \"\"\"\n if A.dtype in (torch.complex64, torch.complex128):\n B = B.to(A.dtype)\n if B.dtype in (torch.complex64, torch.complex128):\n A = A.to(B.dtype)\n return A, B" }, { "identifier": "torch_device", "path": "RotatedMNIST/LPS/emlp-pytorch/emlp_pytorch/reps/utils.py", "snippet": "def torch_device(device):\n \"\"\" Get the device from a string or torch.device \"\"\"\n if device is None:\n device = 'cpu'\n return torch.empty(0, device=device).device" }, { "identifier": "device_cast", "path": "RotatedMNIST/LPS/emlp-pytorch/emlp_pytorch/reps/utils.py", "snippet": "def device_cast(A, B):\n \"\"\" Casts A and B to the same device, preferring GPU over CPU. \"\"\"\n if A.device.type == 'cuda':\n B = B.to(A.device)\n if B.device.type == 'cuda':\n A = A.to(B.device)\n return A, B" }, { "identifier": "get_dtype", "path": "RotatedMNIST/LPS/emlp-pytorch/emlp_pytorch/reps/utils.py", "snippet": "def get_dtype(operators, dtypes=None):\n \"\"\" Returns the dtype of the first operator that has a dtype attribute. \"\"\"\n if dtypes is None:\n dtypes = []\n for obj in operators:\n if obj is not None and hasattr(obj, 'dtype'):\n dtypes.append(obj.dtype)\n return dtypes[0]" } ]

[ { "identifier": "get_system_info", "path": "src/inf.py", "snippet": "def get_system_info(target_text_widget=None):\n if target_text_widget is None:\n return \"Error: target_text_widget not provided.\"\n\n # System information\n system_info_text = \"System Information:\\n\"\n system_info_text += f\" Operating System: {platform.system()} {platform.version()}\\n\"\n system_info_text += f\" Processor: {platform.processor()} ({os.cpu_count()} cores)\\n\"\n system_info_text += f\" Architecture: {platform.architecture()[0]}\\n\"\n system_info_text += get_memory_info() + \"\\n\"\n system_info_text += get_disk_info() + \"\\n\"\n\n # Network information\n system_info_text += \"\\nNetwork Information:\\n\"\n system_info_text += f\" Hostname: {socket.gethostname()}\\n\"\n system_info_text += f\" Internal IP: {socket.gethostbyname(socket.gethostname())}\\n\"\n system_info_text += f\" External IP: {get_external_ip()}\\n\\n\"\n\n target_text_widget.setPlainText(system_info_text)" }, { "identifier": "check_user_in_urls", "path": "src/usr.py", "snippet": "def check_user_in_urls(target_username, urls):\n results = {}\n\n for url in urls:\n full_url = urljoin(url, target_username)\n\n try:\n response = requests.get(full_url, timeout=10)\n if response.status_code == 200:\n results[full_url] = \"Username Found\"\n else:\n results[full_url] = \"Username Not Found\"\n except requests.RequestException:\n results[full_url] = \"Error\"\n\n return results" } ]

[ { "identifier": "CURRENT_TEST_STRATEGY", "path": "tests/conftest.py", "snippet": "CURRENT_TEST_STRATEGY = 'StrategyTestV3'" }, { "identifier": "log_has", "path": "tests/conftest.py", "snippet": "def log_has(line, logs):\n \"\"\"Check if line is found on some caplog's message.\"\"\"\n return any(line == message for message in logs.messages)" }, { "identifier": "log_has_re", "path": "tests/conftest.py", "snippet": "def log_has_re(line, logs):\n \"\"\"Check if line matches some caplog's message.\"\"\"\n return any(re.match(line, message) for message in logs.messages)" }, { "identifier": "patched_configuration_load_config_file", "path": "tests/conftest.py", "snippet": "def patched_configuration_load_config_file(mocker, config) -> None:\n mocker.patch(\n 'freqtrade.configuration.load_config.load_config_file',\n lambda *args, **kwargs: config\n )" } ]

[ { "identifier": "nn", "path": "shallowgrad/nn.py", "snippet": "class nn:\n class loss:\n instances = [] \n @staticmethod\n def backward_prop(g_loss): # g of loss \n delta = np.copy(g_loss)\n for i in reversed(range(len(nn.loss.instances))):\n delta = nn.loss.instances[i].backward(delta)\n\n # Activation functions\n class Softmax:\n @staticmethod\n def __call__(x):\n x = x - np.max(x, axis=1, keepdims=True)\n exp_x = np.exp(x)\n return exp_x / np.sum(exp_x, axis=1, keepdims=True)\n @staticmethod\n def __repr__():\n return \"Softmax applied in place\"\n @staticmethod\n def backward(x):\n return x * (1 - x)\n\n class ReLU:\n @staticmethod\n def __call__(x):\n return np.maximum(0,x)\n @staticmethod\n def __repr__():\n return \"ReLU applied in place\"\n @staticmethod\n def backward(x): \n return (x > 0).astype(int)\n\n class LeakyReLU:\n @staticmethod\n def __call__(x,a=0.5):\n return np.maximum(a * x, x)\n @staticmethod\n def __repr__():\n return \"LeakyReLU applied in place\"\n @staticmethod\n def backward(x,a=0.5):\n return (x > 0).astype(int) + (a * (x <= 0)).astype(int)\n \n class Tanh:\n @staticmethod\n def __call__(x):\n return np.tanh(x)\n @staticmethod\n def __repr__():\n return \"Tanh applied in place\"\n @staticmethod\n def backward(x):\n return 1 - np.tanh(x) ** 2\n \n class Sigmoid:\n @staticmethod\n def __call__(x):\n if x >= 0:\n return 1 / (1 + np.exp(-x))\n else:\n return np.exp(x) / (1 + np.exp(x)) \n @staticmethod\n def __repr__():\n return \"Sigmoid applied in place\"\n @staticmethod\n def backward(x):\n return (1 / (1 + np.exp(-x))) * (1 - (1 / (1 + np.exp(-x))))\n\n # Loss functions\n class MeanSquaredLoss(loss):\n def __init__(self):\n self.y_pred = None\n self.y_true = None\n super().__init__()\n\n def __call__(self,y_pred,y_true):\n self.y_pred = y_pred; self.y_true = y_true\n return ((self.y_true - self.y_pred) ** 2).mean()\n\n def backwards(self):\n g = 2 * (self.y_pred - self.y_true) / len(self.y_true) \n self.backward_prop(g)\n\n class CrossEntropyLoss(loss): \n def __init__(self):\n self.y_pred = None\n self.y_true = None\n self.e = 1e-10\n super().__init__()\n\n def __call__(self, y_pred, y_true):\n self.y_true = y_true\n \n if len(y_true.shape) == 1 or y_true.shape[1] == 1: # convert to one-hot\n num_classes = np.max(y_true) + 1\n one_hot = np.eye(num_classes)[y_true.flatten()]\n one_hot = one_hot.reshape(-1, num_classes)\n self.y_true = one_hot\n \n self.y_pred = nn.Softmax()(y_pred)\n self.y_pred = np.clip(self.y_pred, self.e, 1 - self.e)\n return np.mean(-np.sum(self.y_true * np.log(self.y_pred + self.e), axis=1))\n\n def backwards(self):\n g = (self.y_pred - self.y_true) / self.y_true.shape[0]\n self.backward_prop(g)\n\n class BinaryCrossEntropyLoss(loss):\n def __init__(self):\n self.y_pred = None\n self.y_true = None\n super().__init__()\n self.e = 1e-15 \n\n def __call__(self,y_pred,y_true):\n self.y_pred = y_pred; self.y_true = y_true\n return -np.mean((self.y_true * np.log(self.y_pred + self.e)) \\\n + ((1 - self.y_true) * np.log(1 - self.y_pred + self.e)))\n\n def backwards(self):\n g = (self.y_pred - self.y_true) / ((self.y_pred + self.e) * (1 - self.y_pred + self.e))\n self.backward_prop(g)\n\n\n class Linear:\n def __init__(self,in_features,out_features,bias=True,activation=None):\n self.in_features = in_features\n self.out_features = out_features\n self.use_bias = bias\n self.bias = None\n self.activation_func = activation\n self.weights = self._weight_init()\n self.grad = None\n self.forward_pass = None\n self.x = None\n self.grad_bias = None\n nn.loss.instances.append(self) # record instance for backprop\n super().__init__()\n\n if activation == 'ReLU':\n self.activation_func = nn.ReLU()\n elif activation == 'LeakyReLU':\n self.activation_func = nn.LeakyReLU()\n elif activation == 'Tanh':\n self.activation_func = nn.Tanh()\n elif activation == 'Sigmoid':\n self.activation_func = nn.Sigmoid()\n elif activation == 'Softmax':\n self.activation_func = nn.Softmax()\n else: self.activation_func = None\n\n def __call__(self,x): # forward\n self.x = x\n if self.activation_func is not None:\n self.forward_pass = self.activation_func((self.x.dot(self.weights) + self.bias))\n else:\n self.forward_pass = self.x.dot(self.weights) + self.bias\n return self.forward_pass\n \n def __repr__(self):\n return f\"Linear(in_features={self.in_features}, out_features={self.out_features}, activation={self.activation_func})\"\n\n def _weight_init(self):\n \"\"\"Glorot uniform initialization\"\"\"\n self.bias = np.random.uniform(size=(1,self.out_features)) * 0.05 if self.bias else 0\n v = np.sqrt(2.0 / (self.in_features + self.out_features))\n return np.random.normal(0, v, size=(self.in_features, self.out_features)) \n\n def backward(self, delta):\n if self.activation_func is not None:\n # Calculate gradient of the activation function\n delta = delta * self.activation_func.backward(self.forward_pass)\n # Compute gradients for weights and bias\n self.grad = np.dot(self.x.T, delta)\n if self.use_bias: self.grad_bias = np.sum(delta, axis=0, keepdims=True)\n # Compute gradient with respect to x\n d_x = np.dot(delta, self.weights.T)\n return d_x" }, { "identifier": "Adam", "path": "optimizers/optimizers.py", "snippet": "class Adam:\n def __init__(self,layers=[],lr=0.001,b1=0.9,b2=0.999,e=1e-10):\n self.layers = layers\n self.lr = lr\n self.b1 = b1 \n self.b2 = b2\n self.e = e\n self.t = 0 \n\n self.m = [np.zeros_like(l.weights) for l in self.layers]\n self.v = [np.zeros_like(l.weights) for l in self.layers]\n self.m_bias = [np.zeros_like(l.bias) for l in self.layers if l.use_bias]\n self.v_bias = [np.zeros_like(l.bias) for l in self.layers if l.use_bias]\n\n def step(self):\n for i,l in enumerate(self.layers):\n self.t += 1\n self.m[i] = self.b1 * self.m[i] + (1 - self.b1) * l.grad\n self.v[i] = self.b2 * self.v[i] + (1 - self.b2) * np.square(l.grad)\n m_hat = self.m[i] / (1 - self.b1 ** self.t)\n v_hat = self.v[i] / (1 - self.b2 ** self.t)\n l.weights -= self.lr * m_hat / (np.sqrt(v_hat) + self.e)\n \n if l.use_bias:\n self.m_bias[i] = self.b1 * self.m_bias[i] + (1 - self.b1) * l.grad_bias\n self.v_bias[i] = self.b2 * self.v_bias[i] + (1 - self.b2) * np.square(l.grad_bias)\n m_hat_bias = self.m_bias[i] / (1 - self.b1 ** self.t)\n v_hat_bias = self.v_bias[i] / (1 - self.b2 ** self.t)\n l.bias -= self.lr * m_hat_bias / (np.sqrt(v_hat_bias) + self.e)" } ]

[ { "identifier": "extract_pdf_text", "path": "utils.py", "snippet": "def extract_pdf_text(file):\n \"\"\"\n Extracts text paragraphs from a PDF file.\n \"\"\"\n pdf_reader = PyPDF2.PdfReader(file)\n pdf_dict={}\n for ip in range(len(pdf_reader.pages)):\n pdf_dict[ip] = pdf_reader.pages[ip].extract_text()\n dataset = [pdf_dict[ip] for ip in range(len(pdf_reader.pages))]\n return pdf_dict,dataset" }, { "identifier": "highlight_phrases_in_paragraph", "path": "text_effects.py", "snippet": "def highlight_phrases_in_paragraph(paragraph, phrases_to_colors):\n \"\"\"\n Highlights specific phrases within a paragraph in Streamlit markdown using generated pale colors and rounded edges.\n \n Args:\n - paragraph (str): The paragraph of text where phrases will be highlighted.\n - phrases_to_colors (dict): Dictionary where keys are phrases to be highlighted. Colors will be generated automatically.\n \n Returns:\n - None: Directly renders the HTML in Streamlit using markdown.\n \"\"\"\n # Filter out phrases that don't exist in the paragraph\n phrases_present = {phrase: color for phrase, color in phrases_to_colors.items() if re.search(re.escape(phrase), paragraph, re.IGNORECASE)}\n\n # Sort phrases by length in descending order to handle nested phrases\n phrases_sorted = sorted(phrases_present.keys(), key=len, reverse=True)\n\n # Initialize a hue value\n hue = 0\n hue_increment = 1 / len(phrases_sorted) if phrases_sorted else 0 # Prevent division by zero\n \n # Escape phrases for regex and replace them with highlighted HTML\n for phrase in phrases_sorted:\n color_code = generate_pale_color(hue)\n hue += hue_increment # Increment hue to get a different color\n \n escaped_phrase = re.escape(phrase)\n pattern = r'\\b' + escaped_phrase + r'\\b' # Use word boundaries\n replacement = (\n f'<span style=\"background-color: {color_code}; '\n f'border-radius: 0.5em; padding: 0.3em 0.6em;\">{phrase}🔒</span>'\n )\n paragraph = re.sub(pattern, replacement, paragraph, flags=re.IGNORECASE)\n \n # Render the HTML in Streamlit using the markdown function with unsafe_allow_html set to True\n # st.markdown(paragraph, unsafe_allow_html=True)\n return paragraph" }, { "identifier": "Anonymizer", "path": "ner.py", "snippet": "class Anonymizer:\n def __init__(self, model_name=\"Babelscape/wikineural-multilingual-ner\"):\n self.tokenizer = AutoTokenizer.from_pretrained(model_name)\n self.model = AutoModelForTokenClassification.from_pretrained(model_name)\n self.nlp = pipeline(\"ner\", model=self.model, tokenizer=self.tokenizer, grouped_entities=True)\n self.entity_counters = {}\n self.anonymization_map = {}\n self.deanonymization_map = {}\n self.phone_regex = re.compile(r\"\"\"\n (\\+?[\\d\\s-]{0,3}) # International prefix like +1 or 001\n (\\(?\\d+\\)?[\\s-]?) # Area code with optional parentheses and optional separator\n (\\d+[\\s-]?){2,} # The phone number itself with at least two groups of digits, separated by optional spaces or hyphens\n (\\s*(ext|x|ext.)\\s*\\d+)? # Optional extension prefixed by 'ext', 'x', or 'ext.'\n \"\"\", re.VERBOSE)\n self.email_regex = re.compile(r'[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Z|a-z]{2,}')\n\n def _split_text(self, text, chunk_size=60):\n words = text.split()\n for i in range(0, len(words), chunk_size):\n yield ' '.join(words[i:i+chunk_size])\n\n def _get_anonymized_label(self, entity_group):\n if entity_group not in self.entity_counters:\n self.entity_counters[entity_group] = 1\n anonymized_label = f\"{entity_group.lower()}{self.entity_counters[entity_group]}\"\n self.entity_counters[entity_group] += 1\n return anonymized_label\n\n def _anonymize_with_regex(self, text, regex, entity_group):\n matches = regex.finditer(text)\n shift = 0\n for match in matches:\n entity_text = match.group()\n if entity_text not in self.anonymization_map:\n anonymized_label = self._get_anonymized_label(entity_group)\n self.anonymization_map[entity_text] = anonymized_label\n self.deanonymization_map[anonymized_label] = entity_text\n\n start, end = match.span()\n start += shift\n end += shift\n text = text[:start] + self.anonymization_map[entity_text] + text[end:]\n shift += len(self.anonymization_map[entity_text]) - (end - start)\n\n return text\n\n def _anonymize_chunk(self, chunk, entity_types):\n # Anonymize phone numbers and emails first\n if 'PHONE' in entity_types:\n chunk = self._anonymize_with_regex(chunk, self.phone_regex, 'PHONE')\n if 'EMAIL' in entity_types:\n chunk = self._anonymize_with_regex(chunk, self.email_regex, 'EMAIL')\n\n # Proceed with NER-based anonymization\n ner_results = self.nlp(chunk)\n shift = 0\n for entity in ner_results:\n if entity['entity_group'] in entity_types:\n entity_text = entity['word']\n if entity_text not in self.anonymization_map:\n anonymized_label = self._get_anonymized_label(entity['entity_group'])\n self.anonymization_map[entity_text] = anonymized_label\n self.deanonymization_map[anonymized_label] = entity_text\n\n start = entity['start'] + shift\n end = entity['end'] + shift\n chunk = chunk[:start] + self.anonymization_map[entity_text] + chunk[end:]\n shift += len(self.anonymization_map[entity_text]) - (end - start)\n\n return chunk\n\n def anonymize(self, text, entity_types, chunk_size=60):\n chunks = list(self._split_text(text, chunk_size=chunk_size))\n anonymized_chunks = []\n\n for chunk in chunks:\n anonymized_chunk = self._anonymize_chunk(chunk, entity_types)\n anonymized_chunks.append(anonymized_chunk)\n\n return ' '.join(anonymized_chunks)\n\n # def deanonymize(self, anonymized_text):\n # for anonymized_entity, original_entity in self.deanonymization_map.items():\n # anonymized_text = anonymized_text.replace(anonymized_entity, original_entity)\n # return anonymized_text\n\n def deanonymize(self, anonymized_text):\n # Sort keys by length in descending order to replace longer keys first\n for anonymized_entity in sorted(self.deanonymization_map.keys(), key=len, reverse=True):\n original_entity = self.deanonymization_map[anonymized_entity]\n # Use regular expressions to match whole words\n anonymized_text = re.sub(r'\\b' + re.escape(anonymized_entity) + r'\\b', original_entity, anonymized_text)\n return anonymized_text\n\n def get_anonymization_map(self):\n return self.anonymization_map" } ]

[ { "identifier": "DEBUG_PRINT_EXECUTORS", "path": "dynapipe/schedule_opt/schedule_common.py", "snippet": "DEBUG_REPLACE_OP_NAMES_WITH_INSTRS = False\nDEBUG_REPLACE_OP_NAMES_WITH_SCH_STATS = False\nDEBUG_PRINT_EXECUTORS = []\n COMP_THREAD = 0\n COMM_THREAD = 1\ndef _is_last_fw_or_bw_stage(\n flattened_stage_id, n_orig_layers, comm_added=True\n):\ndef _is_fw_stage(flattened_stage_id, n_orig_layers):\ndef _is_comm_stage(flattened_stage_id, n_orig_layers):\ndef _is_first_bw_layer(flattened_stage_id, n_orig_layers):\ndef _get_comp_only_stage_index(flattened_stage_id, n_orig_layers):\n def __init__(\n self,\n name: str,\n fw_times: List[float],\n fw_comm_times: List[float],\n fw_stored_activation_size: List[float],\n fw_peak_activation_size: List[float],\n activation_shapes: List[List[Tuple[int, int, int]]],\n bw_times: List[int],\n bw_comm_times: List[int],\n ):\n def _validate_spec(self):\n def _merge_layers(self, merged2orig: Dict[int, int]):\n def _flatten(self):\n def initialize(self):\n def is_layers_merged(self):\n def __post_init__(self):\n def _merge_layers(self):\n def _flatten(self):\n def initialize(self):\n def __repr__(self) -> str:\n def from_operation(\n cls,\n operation: \"ScheduleOperation\",\n **kwargs,\n ):\n def __init__(\n self,\n executor_id: int,\n thread_id: int,\n n_orig_layers: int,\n assigned_stages: List[Tuple[int, float, bool]],\n is_comm_stage: bool = False,\n include_memory_stats: bool = True,\n parent_executor: Optional[\"ScheduleExecutor\"] = None,\n logger: Optional[logging.Logger] = None,\n ) -> None:\n def reset(self):\n def process_name(self):\n def thread_name(self):\n def full_name(self):\n def debug_print(self, *args):\n def get_metadata(self):\n def _get_duration_event(self, name, start_time, duration):\n def get_exec_event(\n self,\n op: ScheduleOperation,\n start_time,\n duration,\n ):\n def get_comm_event(\n self,\n op: ScheduleOperation,\n start_time,\n duration,\n ):\n def get_memory_event(self, time, memory, event_type):\n def update_memory(\n self, peak_time, peak_memory, stored_time, stored_memory\n ):\n def __init__(\n self,\n minibatch_spec: SchedulerMinibatchSpec,\n include_memory_stats: bool = True,\n memory_limit: float = float(\"inf\"),\n logger: Optional[logging.Logger] = None,\n ) -> None:\n def _get_executor(\n self,\n executor_id,\n thread_id,\n n_orig_layers,\n assigned_stages,\n is_comm_stage,\n include_memory_stats,\n memory_limit=float(\"inf\"),\n separate_comm_stage=False,\n parent_executor=None,\n ):\n def _initialize(self):\n def _get_next_executor(self, flattened_stage_id):\n def _get_op(self, flattened_stage_id: int, microbatch_id: int):\n def _get_metadata(self):\n def get_executor_peak_memory(self) -> Dict[str, float]:\n def get_makespan(self) -> float:\n def _get_trace_events(self) -> Dict[str, Any]:\n def schedule(self, **kwargs):\n def get_instructions(self):\nclass ExecutorThread:\nclass SchedulerMicrobatchSpec:\nclass SchedulerMinibatchSpec:\nclass ScheduleOperation:\nclass ScheduleExecutor:\nclass Scheduler:" }, { "identifier": "WaitFreeExecutor", "path": "dynapipe/schedule_opt/wait_free_schedule.py", "snippet": "class WaitFreeExecutor(ScheduleExecutor):\n def __init__(self, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.available_queue: List[ScheduleOperation] = []\n\n def add_operation(self, op: ScheduleOperation):\n raise NotImplementedError\n\n def try_execute(self, current_time):\n raise NotImplementedError\n\n def finish_execute(self):\n raise NotImplementedError" }, { "identifier": "WaitFreeScheduler", "path": "dynapipe/schedule_opt/wait_free_schedule.py", "snippet": "class WaitFreeScheduler(Scheduler):\n def __init__(\n self,\n minibatch_spec: SchedulerMinibatchSpec,\n include_memory_stats: bool = True,\n memory_limit: float = float(\"inf\"),\n logger: Optional[logging.Logger] = None,\n ) -> None:\n super().__init__(\n minibatch_spec,\n include_memory_stats,\n memory_limit,\n logger=logger,\n )\n self._initialize()\n self._pending_events: PriorityQueue[CompleteEvent] = PriorityQueue()\n self.executors: Dict[ExecutorIndex, WaitFreeExecutor]\n\n def _get_executor(\n self,\n executor_id,\n thread_id,\n n_orig_layers,\n assigned_stages,\n is_comm_stage,\n include_memory_stats,\n memory_limit=float(\"inf\"),\n ):\n # overrides Scheduler\n raise NotImplementedError\n\n def _init_executors(self, n_microbatches, **kwargs):\n for executor in self.executors.values():\n executor.reset()\n self.communication_executors = [\n executor\n for executor in self.executors.values()\n if executor.is_comm_stage\n ]\n self.computation_executors = [\n executor\n for executor in self.executors.values()\n if not executor.is_comm_stage\n ]\n return True\n\n def _inject_microbatches(\n self, microbatch_offset: int, n_microbatches: int\n ):\n for microbatch_id in range(\n microbatch_offset, microbatch_offset + n_microbatches\n ):\n executor = self.executors[\n self.minibatch_spec.flattened_executor_assignment[0]\n ]\n op = self._get_op(0, microbatch_id)\n executor.add_operation(op)\n\n def _on_op_finish(self, executor: WaitFreeExecutor, op: ScheduleOperation):\n executor.finish_execute()\n if op.flattened_stage < self.n_flattened_stages - 1:\n next_layer = op.flattened_stage + 1\n next_executor = self.minibatch_spec.flattened_executor_assignment[\n next_layer\n ]\n self.executors[next_executor].add_operation(\n self._get_op(next_layer, op.microbatch)\n )\n\n def _push_end_event(self, op, executor, end_time):\n self._pending_events.put(CompleteEvent(end_time, op, executor))\n\n def schedule(self, **kwargs):\n n_microbatches = len(self.minibatch_spec.microbatches)\n status = self._init_executors(n_microbatches, **kwargs)\n if not status:\n return None\n self._inject_microbatches(0, n_microbatches)\n trace_events = self._get_trace_events()\n current_time = 0\n\n def __try_execute():\n # priortize communication executors\n for executor in (\n self.communication_executors + self.computation_executors\n ):\n end_time, launched_op, events = executor.try_execute(\n current_time\n )\n if launched_op:\n self._push_end_event(launched_op, executor, end_time)\n trace_events[\"traceEvents\"].extend(events)\n\n while True:\n __try_execute()\n if self._pending_events.empty():\n break\n else:\n next_event = self._pending_events.get()\n current_time = next_event.completion_time\n ready_events = [next_event]\n while not self._pending_events.empty():\n # try to process all events that finish at the same time\n another_event = self._pending_events.get()\n if another_event.completion_time <= current_time + 1e-6:\n ready_events.append(another_event)\n else:\n self._pending_events.put(another_event)\n break\n for event in ready_events:\n self._on_op_finish(event.executor, event.op)\n self.makespan = current_time\n # make sure all executors are empty\n for executor_idx, executor in self.executors.items():\n if hasattr(executor, \"available_queue\"):\n assert len(executor.available_queue) == 0, (\n f\"Executor {executor_idx} has non-empty ready queue \"\n f\"at end of scheduling: {executor.available_queue}\"\n )\n if hasattr(executor, \"next_op_idx\"):\n assert executor.next_op_idx == len(executor.operator_order), (\n f\"Executor {executor_idx} has not finished all operations \"\n f\"at end of scheduling: {executor.available_queue}\"\n )\n return trace_events" } ]

[ { "identifier": "Data", "path": "actions/chitchat/data_processing.py", "snippet": "class Data(object):\n def __init__(self, config) -> None:\n self.config = config\n self.seq_path = config[\"data_path\"] + config[\"dataset\"] + \".data\"\n self.conv_path = config[\"data_path\"] + config[\"dataset\"] + \".conv\"\n self.conv_size = os.path.getsize(self.conv_path)\n self.vacab_path_in = config[\"data_path\"] + config[\"dataset\"] + \".vin\"\n self.vacab_path_out = config[\"data_path\"] + config[\"dataset\"] + \".vout\"\n self.max_length = config[\"max_length\"]\n self.batch_size = config[\"batch_size\"]\n self.LOG = logging.getLogger(\"Data\")\n logging.basicConfig(level=logging.INFO)\n jieba.setLogLevel(logging.INFO) # Disable debug info\n\n def create_sequences(self):\n if os.path.exists(self.seq_path): # Skip if processed data exists\n return\n\n # 判断训练语料文件是否存在，如果不存在则进行提醒\n if not os.path.exists(self.conv_path):\n self.LOG.info(\"找不到语料文件，请检查路径\")\n exit()\n\n self.LOG.info(\"正在处理语料\")\n # 打开需要处理的语料，逐条读取并进行数据处理, 新建一个文件，用于存放处理后的对话语料\n with tqdm(total=self.conv_size) as pbar, open(self.conv_path, encoding=\"utf-8\") as fin, open(self.seq_path, \"w\") as fout:\n one_conv = \"\" # 存储一次完整对话\n for line in fin:\n pbar.update(len(line.encode(\"utf-8\")))\n line = line.strip(\"\\n\")\n # line = re.sub(r\"[%s]+\" % punctuation, \"\", line) # 去除标点符号\n if not line:\n continue\n # 判断是否为一段对话的开始，如果是则把刚刚处理的语料保存下来\n if line[0] == self.config[\"e\"]:\n if one_conv:\n fout.write(one_conv[:-1] + \"\\n\")\n one_conv = \"\"\n # 判断是否正在处理对话语句，如果是则进行语料的拼接处理 以及分词\n elif line[0] == self.config[\"m\"]:\n one_conv = one_conv + str(\" \".join(jieba.cut(line.split(\" \")[1]))) + \"\\t\" # 存储一次问或答\n\n def _create_vacab(self, lang, vocab_path, vocab_size):\n if os.path.exists(vocab_path): # Skip if exists\n return\n\n tokenizer = tf.keras.preprocessing.text.Tokenizer(num_words=vocab_size, oov_token=\"<UNK>\")\n tokenizer.fit_on_texts(lang)\n with open(vocab_path, \"w\", encoding=\"utf-8\") as f:\n f.write(tokenizer.to_json(ensure_ascii=False))\n\n self.LOG.info(f\"正在保存: {vocab_path}\")\n\n def create_vacabularies(self):\n if os.path.exists(self.vacab_path_in) and os.path.exists(self.vacab_path_out): # Skip if exists\n return\n\n self.LOG.info(f\"正在创建字典\")\n lines = io.open(self.seq_path, encoding=\"UTF-8\").readlines()\n word_pairs = [[add_flag(w) for w in l.split(\"\\t\")] for l in lines]\n input, target = zip(*word_pairs)\n self._create_vacab(input, self.vacab_path_in, self.config[\"vacab_size_in\"])\n self._create_vacab(target, self.vacab_path_out, self.config[\"vacab_size_out\"])\n\n def _tokenize(self, path):\n # 定义word2number函数，通过对语料的处理提取词典，并进行word2number处理以及padding补全\n # 从词典中读取预先生成tokenizer的config，构建词典矩阵\n with open(path, \"r\", encoding=\"utf-8\") as f:\n tokenize_config = json.dumps(json.load(f), ensure_ascii=False)\n tokenizer = tf.keras.preprocessing.text.tokenizer_from_json(tokenize_config)\n # 利用词典进行word2number的转换以及padding处理\n return tokenizer\n\n def process(self):\n self.create_sequences()\n self.create_vacabularies()\n\n def load(self):\n self.process()\n lines = io.open(self.seq_path, encoding=\"UTF-8\").readlines()\n word_pairs = [[add_flag(w) for w in l.split(\"\\t\")] for l in lines]\n words_in, words_out = zip(*word_pairs)\n tokenizer_in = self._tokenize(self.vacab_path_in)\n tokenizer_out = self._tokenize(self.vacab_path_out)\n\n tensor_in = tokenizer_in.texts_to_sequences(words_in)\n tensor_out = tokenizer_out.texts_to_sequences(words_out)\n\n tensor_in = tf.keras.preprocessing.sequence.pad_sequences(tensor_in, maxlen=self.max_length, padding=\"post\")\n tensor_out = tf.keras.preprocessing.sequence.pad_sequences(tensor_out, maxlen=self.max_length, padding=\"post\")\n\n self.steps_per_epoch = len(tensor_in) // self.batch_size\n BUFFER_SIZE = len(tensor_in)\n dataset = tf.data.Dataset.from_tensor_slices((tensor_in, tensor_out)).shuffle(BUFFER_SIZE)\n dataset = dataset.batch(self.batch_size, drop_remainder=True)\n\n return dataset, tokenizer_in, tokenizer_out" }, { "identifier": "add_flag", "path": "actions/chitchat/data_processing.py", "snippet": "def add_flag(w):\n return \"<bos> \" + w + \" <eos>\"" } ]

[ { "identifier": "surge2singbox", "path": "surge2singbox.py", "snippet": "def surge2singbox(surge_config_path):\n singbox_rules = []\n\n with open(surge_config_path, 'r', encoding='utf-8') as f:\n surge_config = f.readlines()\n reg = r'^\\[(.+)\\]$'\n sections = {}\n for linenum, line in enumerate(surge_config):\n if re.match(reg, line):\n sections[re.match(reg, line).group(1)] = linenum\n if 'Rule' not in sections:\n print('Error: Rule section not found')\n sys.exit(1)\n \n if list(sections.keys()).index('Rule') == len(sections.keys()) - 1:\n surge_config = surge_config[sections['Rule'] + 1:]\n else:\n surge_config = surge_config[sections['Rule'] + 1:sections[list(sections.keys())[list(sections.keys()).index('Rule') + 1]]]\n hasLAN = False\n for line in surge_config:\n if line.startswith('#') or len(line.strip()) == 0 or len(line.split(',')) < 2:\n continue\n if line.upper().split(',')[1].strip() == 'LAN':\n hasLAN = True\n break\n extras = []\n for line in surge_config:\n if line.startswith('#') or len(line.strip()) == 0:\n continue\n if line.upper().startswith('RULE-SET'):\n singbox_rule = get_singbox_ruleset(line.split(',')[1].strip(), line.split(',')[2].strip())\n if singbox_rule != -1:\n singbox_rules.append(singbox_rule)\n extras.append(line.split(',')[2].strip())\n elif line.upper().startswith('DOMAIN-SET'):\n singbox_rule = get_singbox_domainset(line.split(',')[1].strip(), line.split(',')[2].strip())\n if singbox_rule != -1:\n singbox_rules.append(singbox_rule)\n extras.append(line.split(',')[2].strip())\n elif line.upper().startswith('AND') or line.upper().startswith('OR'):\n singbox_rule = get_singbox_logical(line, line.split(',')[2].strip())\n if singbox_rule != -1:\n singbox_rules.append(singbox_rule)\n extras.append(line.split(',')[2].strip())\n else:\n singbox_rule = get_singbox_rule(line, line.split(',')[2].strip(), hasLAN=hasLAN)\n if singbox_rule != -1:\n singbox_rules.append(singbox_rule)\n extras.append(line.split(',')[2].strip())\n\n singbox_rules = np.flip(singbox_rules, axis=0).tolist()\n singbox_rules.append({'protocol': 'dns', 'outbound': 'dns-out'})\n config = {}\n config['route'] = {}\n config['route']['rules'] = singbox_rules\n\n return config, extras" }, { "identifier": "clash2singbox", "path": "clash2singbox.py", "snippet": "def clash2singbox(clash_config_path, policies, extras=[]):\n bUS = policies[0]\n bHK = policies[1]\n bSG = policies[2]\n bJP = policies[3]\n bTW = policies[4]\n\n with open(clash_config_path, 'r', encoding='utf-8') as stream:\n data_loaded = yaml.safe_load(stream)\n data_loaded = data_loaded['proxies']\n sb_proxies = []\n names = []\n for proxy in data_loaded:\n if proxy['type'] not in supported_types:\n continue\n sb_proxy = {}\n if proxy['type'] == 'ss':\n sb_proxy['type'] = 'shadowsocks'\n sb_proxy['tag'] = proxy['name']\n names.append(proxy['name'])\n sb_proxy['server'] = proxy['server']\n sb_proxy['server_port'] = proxy['port']\n sb_proxy['method'] = proxy['cipher']\n sb_proxy['password'] = proxy['password']\n if 'plugin' in proxy and proxy['plugin'] == 'obfs':\n sb_proxy['plugin'] = 'obfs-local'\n if 'plugin-opts' in proxy:\n opts = ''\n for key in proxy['plugin-opts']:\n if key == 'mode':\n opts += 'obfs=' + proxy['plugin-opts'][key] + ';'\n elif key == 'host':\n opts += 'obfs-host=' + proxy['plugin-opts'][key]\n sb_proxy['plugin_opts'] = opts\n elif proxy['type'] == 'vmess':\n sb_proxy['type'] = 'vmess'\n sb_proxy['tag'] = proxy['name']\n names.append(proxy['name'])\n sb_proxy['server'] = proxy['server']\n sb_proxy['server_port'] = proxy['port']\n sb_proxy['uuid'] = proxy['uuid']\n sb_proxy['alter_id'] = proxy['alterId']\n sb_proxy['security'] = proxy['cipher']\n elif proxy['type'] == 'trojan':\n sb_proxy['type'] = 'trojan'\n sb_proxy['tag'] = proxy['name']\n names.append(proxy['name'])\n sb_proxy['server'] = proxy['server']\n sb_proxy['server_port'] = proxy['port']\n sb_proxy['password'] = proxy['password']\n if 'sni' in proxy:\n tls = {}\n tls['enabled'] = True\n tls['server_name'] = proxy['sni']\n if 'skip-cert-verify' in proxy:\n tls['insecure'] = proxy['skip-cert-verify']\n if 'alpn' in proxy:\n tls['alpn'] = proxy['alpn']\n sb_proxy['tls'] = tls\n\n sb_proxies.append(sb_proxy)\n\n selector = {}\n selector['type'] = 'selector'\n selector['tag'] = 'OutSide'\n selector['outbounds'] = names\n selector['default'] = names[0]\n sb_proxies.append(selector)\n us_policy = {}\n us_policy['type'] = 'selector'\n us_policy['tag'] = 'United States'\n us_policy['outbounds'] = []\n hk_policy = {}\n hk_policy['type'] = 'selector'\n hk_policy['tag'] = 'Hong Kong'\n hk_policy['outbounds'] = []\n sg_policy = {}\n sg_policy['type'] = 'selector'\n sg_policy['tag'] = 'Singapore'\n sg_policy['outbounds'] = []\n jp_policy = {}\n jp_policy['type'] = 'selector'\n jp_policy['tag'] = 'Japan'\n jp_policy['outbounds'] = []\n tw_policy = {}\n tw_policy['type'] = 'selector'\n tw_policy['tag'] = 'Taiwan'\n tw_policy['outbounds'] = []\n for name in names:\n if re.search(us_regex, name, re.IGNORECASE):\n us_policy['outbounds'].append(name)\n elif re.search(hk_regex, name, re.IGNORECASE):\n hk_policy['outbounds'].append(name)\n elif re.search(sg_regex, name, re.IGNORECASE):\n sg_policy['outbounds'].append(name)\n elif re.search(jp_regex, name, re.IGNORECASE):\n jp_policy['outbounds'].append(name)\n elif re.search(tw_regex, name, re.IGNORECASE):\n tw_policy['outbounds'].append(name)\n \n if bUS:\n sb_proxies.append(us_policy)\n if bHK:\n sb_proxies.append(hk_policy)\n if bSG:\n sb_proxies.append(sg_policy)\n if bJP:\n sb_proxies.append(jp_policy)\n if bTW:\n sb_proxies.append(tw_policy)\n\n if len(extras) > 0:\n countries = []\n if bUS:\n countries.append('United States')\n if bHK:\n countries.append('Hong Kong')\n if bSG:\n countries.append('Singapore')\n if bJP:\n countries.append('Japan')\n if bTW:\n countries.append('Taiwan')\n countries.append('direct')\n countries.append('block')\n for extra in extras:\n policy = {}\n policy['type'] = 'selector'\n policy['tag'] = extra\n policy['outbounds'] = countries\n sb_proxies.append(policy)\n\n out_conf = {}\n out_conf['outbounds'] = sb_proxies\n\n return out_conf" } ]

[ { "identifier": "EnvironmentContrastiveBatch", "path": "reed/data/environment_transition_dataset.py", "snippet": "class EnvironmentContrastiveBatch:\n \"\"\"\n A batch of triplets where two states/observations are given and one is an augmented version of the other.\n\n The augmentation may be along the lines of random crop, jitter, etc or may be a temporal augmentation where the\n augmented state occurs in the future\n \"\"\"\n states = attr.ib(type=t.Union[torch.Tensor, PackedSequence])\n actions = attr.ib(type=t.Union[torch.Tensor, PackedSequence])\n augmented_states = attr.ib(type=t.Union[torch.Tensor, PackedSequence])\n\n def to_dict(self) -> t.Mapping[str, t.Union[torch.Tensor, PackedSequence]]:\n \"\"\"\n Return the attr as a dictionary\n \"\"\"\n return {\"states\": self.states,\n \"actions\": self.actions,\n \"augmented_states\": self.augmented_states}" }, { "identifier": "get_image_encoder", "path": "reed/models/image_encoder.py", "snippet": "def get_image_encoder(architecture: str, obs_dim: t.List[int], out_size: int = 1,\n hidden_dim: int = 128, hidden_depth: int = 3,\n image_hidden_num_channels: int = 32,\n *kwargs) -> nn.Module:\n \"\"\"\n Return the specified architecture initialized\n\n Args:\n architecture: which image encoder architecture to use\n obs_dim: dimensionality of the state images (height, width, channels)\n out_size: the size of the output\n hidden_dim: the size of the hidden layer(s)\n hidden_depth: the number of hidden layers\n image_hidden_num_channels: (default = 32) the number of channels in the hidden layers of the image encoder\n Returns:\n initialized image encoder\n \"\"\"\n if architecture == \"pixl2r\":\n # from PixL2R: https://arxiv.org/pdf/2007.15543.pdf & https://github.com/prasoongoyal/PixL2R/blob/b0691be6b27e705a62534b58f97ff7b8b6655c7d/src/supervised/model.py#L52\n return PixL2RImageEncoder(obs_dim=obs_dim, out_size=out_size,\n hidden_dim=hidden_dim, hidden_depth=hidden_depth,\n image_hidden_num_channels=image_hidden_num_channels)\n elif architecture == \"drqv2\":\n # from drqv2: https://github.com/facebookresearch/drqv2/blob/c0c650b76c6e5d22a7eb5f2edffd1440fe94f8ef/drqv2.py#L55\n return DRQv2ImageEncoder(obs_dim=obs_dim, out_size=out_size,\n hidden_dim=hidden_dim, hidden_depth=hidden_depth,\n image_hidden_num_channels=image_hidden_num_channels)\n else:\n raise NotImplementedError(f\"{architecture} is not an implemented image \"\n f\"encoder architecture\")" }, { "identifier": "StateActionSelfPredictiveRepresentationsNetworkEnsemble", "path": "reed/models/self_predictive_representations_model.py", "snippet": "class StateActionSelfPredictiveRepresentationsNetworkEnsemble(nn.Module):\n def __init__(self,\n device: torch.device,\n networks: t.Sequence[nn.Module]):\n \"\"\"\n Initial pass at an ensemble of networks used to train state-action representations that are consistent with\n the network's encoding of the state that results from applying the given action in the given state\n\n Args:\n device: which GPU or CPU device the network is to be run on\n networks: the networks that will make up the ensemble\n \"\"\"\n super(StateActionSelfPredictiveRepresentationsNetworkEnsemble, self).__init__()\n\n # convert the list of networks into a pytorch network list\n self._ensemble = nn.ModuleList(networks)\n\n # track the device\n self.device = device\n\n def __len__(self) -> int:\n \"\"\"\n The number of networks in the ensemble\n \"\"\"\n return len(self._ensemble)\n\n def __getitem__(self, item: int) -> nn.Module:\n return self._ensemble[item]\n\n def forward(self,\n transitions: t.List[EnvironmentContrastiveBatch]) -> t.Tuple[t.Sequence[torch.Tensor], t.Sequence[torch.Tensor]]:\n \"\"\"\n For each network, predict the representation of the next state and encode the given next state\n\n Args:\n transitions: a batch of environment transitions composed of states, actions, and next states for each\n network in the ensemble\n Returns:\n predicted embedding of the next state - p in the SimSiam paper\n next state embedding (detached from the tensor graph) - z in the SimSiam paper\n dimensionality: (batch, time step)\n \"\"\"\n next_state_preds = []\n projected_next_state_embeds = []\n for net_indx, net_batch in enumerate(transitions):\n net = self._ensemble[net_indx]\n # we need to convert the batch object a dictionary in case we are using nn.DataParallel\n next_state_pred, projected_next_state_embed = net(attr.asdict(net_batch))\n next_state_preds.append(next_state_pred)\n projected_next_state_embeds.append(projected_next_state_embed)\n\n # from the SimSiam paper, this is p and z\n return next_state_preds, projected_next_state_embeds\n\n def save(self, model_dir: Path, env_id: str, step: int):\n \"\"\"\n Save the ensemble to disk\n Args:\n model_dir: location to save the SFC nets\n env_id: the string identifier for the environment\n step: number of overall training steps taken before this save\n\n Returns:\n\n \"\"\"\n for net_indx, net in enumerate(self._ensemble):\n torch.save(net.state_dict(), f'{model_dir.as_posix()}/{env_id}_sfc_model_{step}_{net_indx}.pt')" } ]

[ { "identifier": "BaseConv", "path": "yolox/models/network_blocks.py", "snippet": "class BaseConv(nn.Module):\n \"\"\"A Conv2d -> Batchnorm -> silu/leaky relu block\"\"\"\n\n def __init__(\n self, in_channels, out_channels, ksize, stride, groups=1, bias=False, act=\"silu\"\n ):\n super().__init__()\n # same padding\n pad = (ksize - 1) // 2\n self.conv = nn.Conv2d(\n in_channels,\n out_channels,\n kernel_size=ksize,\n stride=stride,\n padding=pad,\n groups=groups,\n bias=bias,\n )\n self.bn = nn.BatchNorm2d(out_channels)\n self.act = get_activation(act, inplace=True)\n\n def forward(self, x):\n return self.act(self.bn(self.conv(x)))\n\n def fuseforward(self, x):\n return self.act(self.conv(x))" }, { "identifier": "CSPLayer", "path": "yolox/models/network_blocks.py", "snippet": "class CSPLayer(nn.Module):\n \"\"\"C3 in yolov5, CSP Bottleneck with 3 convolutions\"\"\"\n\n def __init__(\n self,\n in_channels,\n out_channels,\n n=1,\n shortcut=True,\n expansion=0.5,\n depthwise=False,\n act=\"silu\",\n ):\n \"\"\"\n Args:\n in_channels (int): input channels.\n out_channels (int): output channels.\n n (int): number of Bottlenecks. Default value: 1.\n \"\"\"\n # ch_in, ch_out, number, shortcut, groups, expansion\n super().__init__()\n hidden_channels = int(out_channels * expansion) # hidden channels\n self.conv1 = BaseConv(in_channels, hidden_channels, 1, stride=1, act=act)\n self.conv2 = BaseConv(in_channels, hidden_channels, 1, stride=1, act=act)\n self.conv3 = BaseConv(2 * hidden_channels, out_channels, 1, stride=1, act=act)\n module_list = [\n Bottleneck(\n hidden_channels, hidden_channels, shortcut, 1.0, depthwise, act=act\n )\n for _ in range(n)\n ]\n self.m = nn.Sequential(*module_list)\n\n def forward(self, x):\n x_1 = self.conv1(x)\n x_2 = self.conv2(x)\n x_1 = self.m(x_1)\n x = torch.cat((x_1, x_2), dim=1)\n return self.conv3(x)" }, { "identifier": "DWConv", "path": "yolox/models/network_blocks.py", "snippet": "class DWConv(nn.Module):\n \"\"\"Depthwise Conv + Conv\"\"\"\n\n def __init__(self, in_channels, out_channels, ksize, stride=1, act=\"silu\"):\n super().__init__()\n self.dconv = BaseConv(\n in_channels,\n in_channels,\n ksize=ksize,\n stride=stride,\n groups=in_channels,\n act=act,\n )\n self.pconv = BaseConv(\n in_channels, out_channels, ksize=1, stride=1, groups=1, act=act\n )\n\n def forward(self, x):\n x = self.dconv(x)\n return self.pconv(x)" }, { "identifier": "Focus", "path": "yolox/models/network_blocks.py", "snippet": "class Focus(nn.Module):\n \"\"\"Focus width and height information into channel space.\"\"\"\n\n def __init__(self, in_channels, out_channels, ksize=1, stride=1, act=\"silu\"):\n super().__init__()\n self.conv = BaseConv(in_channels * 4, out_channels, ksize, stride, act=act)\n\n def forward(self, x):\n # shape of x (b,c,w,h) -> y(b,4c,w/2,h/2)\n patch_top_left = x[..., ::2, ::2]\n patch_top_right = x[..., ::2, 1::2]\n patch_bot_left = x[..., 1::2, ::2]\n patch_bot_right = x[..., 1::2, 1::2]\n x = torch.cat(\n (\n patch_top_left,\n patch_bot_left,\n patch_top_right,\n patch_bot_right,\n ),\n dim=1,\n )\n return self.conv(x)" }, { "identifier": "ResLayer", "path": "yolox/models/network_blocks.py", "snippet": "class ResLayer(nn.Module):\n \"Residual layer with `in_channels` inputs.\"\n\n def __init__(self, in_channels: int):\n super().__init__()\n mid_channels = in_channels // 2\n self.layer1 = BaseConv(\n in_channels, mid_channels, ksize=1, stride=1, act=\"lrelu\"\n )\n self.layer2 = BaseConv(\n mid_channels, in_channels, ksize=3, stride=1, act=\"lrelu\"\n )\n\n def forward(self, x):\n out = self.layer2(self.layer1(x))\n return x + out" }, { "identifier": "SPPBottleneck", "path": "yolox/models/network_blocks.py", "snippet": "class SPPBottleneck(nn.Module):\n \"\"\"Spatial pyramid pooling layer used in YOLOv3-SPP\"\"\"\n\n def __init__(\n self, in_channels, out_channels, kernel_sizes=(5, 9, 13), activation=\"silu\"\n ):\n super().__init__()\n hidden_channels = in_channels // 2\n self.conv1 = BaseConv(in_channels, hidden_channels, 1, stride=1, act=activation)\n self.m = nn.ModuleList(\n [\n nn.MaxPool2d(kernel_size=ks, stride=1, padding=ks // 2)\n for ks in kernel_sizes\n ]\n )\n conv2_channels = hidden_channels * (len(kernel_sizes) + 1)\n self.conv2 = BaseConv(conv2_channels, out_channels, 1, stride=1, act=activation)\n\n def forward(self, x):\n x = self.conv1(x)\n x = torch.cat([x] + [m(x) for m in self.m], dim=1)\n x = self.conv2(x)\n return x" } ]

[ { "identifier": "DOMAIN", "path": "custom_components/king_smith/const.py", "snippet": "DOMAIN = \"king_smith\"" }, { "identifier": "WalkingPadCoordinator", "path": "custom_components/king_smith/coordinator.py", "snippet": "class WalkingPadCoordinator(DataUpdateCoordinator[None]):\n \"\"\"Data coordinator for receiving Walking Pad updates.\"\"\"\n\n def __init__(self, hass: HomeAssistant, walking_pad_api: WalkingPadApi) -> None:\n \"\"\"Initialise the coordinator.\"\"\"\n super().__init__(\n hass,\n _LOGGER,\n name=DOMAIN,\n )\n self._walking_pad_api = walking_pad_api\n self._walking_pad_api.register_status_callback(self._async_handle_update)\n self.connected = self._walking_pad_api.connected\n self._last_update_time = NEVER_TIME\n self._debounce_cancel: CALLBACK_TYPE | None = None\n self._debounced_update_job = HassJob(\n self._async_handle_debounced_update,\n f\"Walking Pad {walking_pad_api.mac} BLE debounced update\",\n )\n\n @callback\n def _async_handle_debounced_update(self, _now: datetime) -> None:\n \"\"\"Handle debounced update.\"\"\"\n self._debounce_cancel = None\n self._last_update_time = time.monotonic()\n self.async_set_updated_data(None)\n\n @callback\n def _async_handle_update(self, status: WalkingPadCurStatus) -> None:\n \"\"\"Just trigger the callbacks.\"\"\"\n self.connected = True\n previous_last_updated_time = self._last_update_time\n self._last_update_time = time.monotonic()\n if self._last_update_time - previous_last_updated_time >= DEBOUNCE_SECONDS:\n self.async_set_updated_data(None)\n return\n if self._debounce_cancel is None:\n self._debounce_cancel = async_call_later(\n self.hass, DEBOUNCE_SECONDS, self._debounced_update_job\n )\n\n @callback\n def _async_handle_disconnect(self) -> None:\n \"\"\"Trigger the callbacks for disconnected.\"\"\"\n self.connected = False\n self.async_update_listeners()\n\n async def async_shutdown(self) -> None:\n \"\"\"Shutdown the coordinator.\"\"\"\n if self._debounce_cancel is not None:\n self._debounce_cancel()\n self._debounce_cancel = None\n await super().async_shutdown()" }, { "identifier": "WalkingPadEntity", "path": "custom_components/king_smith/entity.py", "snippet": "class WalkingPadEntity(CoordinatorEntity[WalkingPadCoordinator]):\n \"\"\"Walking Pad Entity Base Class.\"\"\"\n\n def __init__(self, name: str, walking_pad_api: WalkingPadApi, coordinator) -> None:\n \"\"\"Initialize the entity.\"\"\"\n super().__init__(coordinator)\n self._coordinator = coordinator\n self._walking_pad_api = walking_pad_api\n self.entity_id = generate_entity_id(ENTITY_ID_FORMAT, self._name, [])\n\n @callback\n def _handle_coordinator_update(self) -> None:\n self.async_write_ha_state()\n\n async def async_update(self) -> None:\n \"\"\"Handle an update.\"\"\"\n await self._walking_pad_api.update_state()\n\n @property\n def device_info(self) -> dict[str, Any]:\n \"\"\"Return the device info.\"\"\"\n prop = {\n \"identifiers\": {(DOMAIN, self.unique_id)},\n \"name\": self._name,\n \"manufacturer\": \"King Smith\",\n }\n\n return prop\n\n @property\n def unique_id(self) -> str:\n \"\"\"Return the unique id of the switch.\"\"\"\n return self._walking_pad_api.mac\n\n @property\n def name(self):\n \"\"\"Name.\"\"\"\n return self._name\n\n @property\n def should_poll(self):\n \"\"\"Should poll.\"\"\"\n return True\n\n @property\n def available(self):\n \"\"\"Available.\"\"\"\n return self._walking_pad_api.connected" }, { "identifier": "WalkingPadApi", "path": "custom_components/king_smith/walking_pad.py", "snippet": "class WalkingPadApi:\n \"\"\"Walkingpad device.\"\"\"\n\n def __init__(self, name: str, ble_device: BLEDevice) -> None:\n \"\"\"Create a new walking pad api instance.\"\"\"\n self._name = name\n self._ble_device = ble_device\n self._ctrl = Controller()\n self._callbacks = []\n self._status_lock = False\n self._last_cmd_time = time.time()\n\n self._connected = False\n self._moving = False\n self._speed = 0\n self._distance = 0\n\n self._register_controller_callbacks()\n\n def _register_controller_callbacks(self):\n self._ctrl.handler_cur_status = self._on_status_update\n\n def _begin_cmd(self) -> asyncio.Lock:\n self._status_lock = True\n return asyncio.Lock()\n\n async def _end_cmd(self):\n await asyncio.sleep(0.75)\n self._last_cmd_time = time.time()\n self._status_lock = False\n\n def _on_status_update(self, sender, status: WalkingPadCurStatus) -> None:\n \"\"\"Update current state.\"\"\"\n # Don't update if we're still running a command or just did (status from device is outdated at first)\n if (\n self._status_lock\n or time.time() - self._last_cmd_time < STATUS_LOCK_ON_CMD_SECONDS\n ):\n return\n\n self._moving = status.speed > 0\n self._speed = status.speed\n self._distance = status.dist\n\n if len(self._callbacks) > 0:\n for callback in self._callbacks:\n callback(status)\n\n def register_status_callback(self, callback) -> None:\n \"\"\"Register a status callback.\"\"\"\n self._callbacks.append(callback)\n\n @property\n def mac(self):\n \"\"\"Mac address.\"\"\"\n return self._ble_device.address\n\n @property\n def name(self):\n \"\"\"Name.\"\"\"\n return self._name\n\n @property\n def connected(self):\n \"\"\"Connected status.\"\"\"\n return self._connected\n\n @property\n def moving(self):\n \"\"\"Whether or not the device is currently moving.\"\"\"\n return self._moving\n\n @property\n def speed(self):\n \"\"\"The current device speed.\"\"\"\n return self._speed\n\n @property\n def distance(self):\n \"\"\"The current device distance.\"\"\"\n return self._distance\n\n async def connect(self) -> None:\n \"\"\"Connect the device.\"\"\"\n lock = self._begin_cmd()\n async with lock:\n await self._ctrl.run(self._ble_device)\n self._connected = True\n await self._end_cmd()\n\n async def disconnect(self) -> None:\n \"\"\"Disconnect the device.\"\"\"\n lock = self._begin_cmd()\n async with lock:\n await self._ctrl.disconnect()\n self._connected = False\n await self._end_cmd()\n\n async def turn_on(self) -> None:\n \"\"\"Turn on the device.\"\"\"\n lock = self._begin_cmd()\n async with lock:\n await self._ctrl.switch_mode(WalkingPad.MODE_MANUAL)\n await self._end_cmd()\n\n async def turn_off(self) -> None:\n \"\"\"Turn off the device.\"\"\"\n lock = self._begin_cmd()\n async with lock:\n await self._ctrl.switch_mode(WalkingPad.MODE_STANDBY)\n await self._end_cmd()\n\n async def start_belt(self) -> None:\n \"\"\"Start the belt.\"\"\"\n lock = self._begin_cmd()\n async with lock:\n await self._ctrl.start_belt()\n self._moving = True\n await self._end_cmd()\n\n async def stop_belt(self) -> None:\n \"\"\"Stop the belt.\"\"\"\n lock = self._begin_cmd()\n async with lock:\n await self._ctrl.stop_belt()\n self._moving = False\n await self._end_cmd()\n\n async def change_speed(self, speed: int) -> None:\n \"\"\"Change the speed.\"\"\"\n lock = self._begin_cmd()\n async with lock:\n await self._ctrl.change_speed(speed)\n self._speed = speed\n await self._end_cmd()\n\n async def update_state(self) -> None:\n \"\"\"Update device state.\"\"\"\n # Grab the lock so we don't run while another command is running\n lock = self._begin_cmd()\n async with lock:\n # Disable status lock so our update triggers a refresh\n self._status_lock = False\n await self._ctrl.ask_stats()\n # Skip callback so we don't reset debouncer" } ]

[ { "identifier": "select_bins", "path": "spice/conditional_histogram.py", "snippet": "def select_bins(y: torch.Tensor, n_bins: int) -> torch.Tensor:\n return unique_quantile(y, n_bins, first_bin_zero=False)" }, { "identifier": "discretize", "path": "spice/conditional_histogram.py", "snippet": "def discretize(y: torch.Tensor, bins: torch.Tensor) -> torch.Tensor:\n return torch.bucketize(y.clip(max=bins[-1] - 1e-5), boundaries=bins)" }, { "identifier": "ConditionalHist", "path": "spice/conditional_histogram.py", "snippet": "class ConditionalHist(BaseLightning):\n def __init__(\n self, input_dim: int, hidden_dim: int,\n max_iter: int, bins: torch.Tensor,\n y_min: float,\n lr: float = 1e-3, wd: float = 0,\n ):\n super().__init__()\n self.save_hyperparameters()\n self.module = nn.Sequential(\n MLP(input_dim, hidden=hidden_dim, n_hidden=1, output_dim=bins.shape[0]),\n )\n\n def forward(self, x: torch.Tensor) -> torch.Tensor:\n \"\"\"log bin probabilities\"\"\"\n return torch.log_softmax(self.module(x), dim=-1)\n\n def log_likelihood(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n \"\"\"log likelihood of y | x\"\"\"\n bin_log_probs = self(x)\n return -F.nll_loss(bin_log_probs, y.squeeze(), reduction=\"none\")\n\n def likelihood(self, x: torch.Tensor, y: torch.Tensor) -> torch.Tensor:\n return self.log_likelihood(x, y).exp()\n\n def get_loss(self, batch: list[torch.Tensor], prefix: str) -> torch.Tensor:\n x, y = batch\n loss = -self.log_likelihood(x, y).mean()\n self.epoch_log(f\"{prefix}/loss\", loss)\n return loss\n\n @torch.no_grad()\n def find_prob_threshold(self, x_val: torch.Tensor, y_val: torch.Tensor, alpha: float) -> float:\n \"\"\"\n alpha: mis-classification rate\n anything above threshold in likelihood should be in the prediction set\n https://people.eecs.berkeley.edu/~angelopoulos/publications/downloads/gentle_intro_conformal_dfuq.pdf\n \"\"\"\n n = len(y_val)\n q_level = math.ceil((n + 1) * (1 - alpha)) / n\n cal_scores = 1 - self.likelihood(x_val.to(self.device), y_val.to(self.device))\n q_hat = torch.quantile(cal_scores, q_level, interpolation=\"higher\").item()\n return 1 - q_hat\n\n @torch.no_grad()\n def get_extended_bins(self):\n extended_bins = torch.empty(self.hparams.bins.shape[0] + 1)\n extended_bins[0] = self.hparams.y_min\n extended_bins[1:] = self.hparams.bins\n return extended_bins\n\n @torch.no_grad()\n def get_bin_widths(self) -> torch.Tensor:\n extended_bins = self.get_extended_bins()\n return extended_bins[1:] - extended_bins[:-1]\n\n @torch.no_grad()\n def get_metrics(\n self, x_test: torch.Tensor, y_test: torch.Tensor, threshold: float,\n ) -> dict[str, float]:\n test_prob = self(x_test.to(self.device)).exp().to(y_test.device)\n prediction_set = test_prob > threshold\n covered = (\n (\n F.one_hot(y_test.squeeze(), num_classes=self.hparams.bins.shape[0])\n & prediction_set\n ).any(dim=1)\n ).float()\n bin_sizes = self.get_bin_widths()\n sizes = (bin_sizes.unsqueeze(0) * prediction_set).sum(dim=1)\n return compute_conformal_metrics(x_test, y_test.float() / y_test.max().item(), sizes, covered)\n\n @torch.no_grad()\n def get_hpd_threshold(self, x_val: torch.Tensor, y_val: torch.Tensor, alpha: float) -> float:\n x_val = x_val.to(self.device)\n y_val = y_val.to(self.device)\n all_probs = self(x_val).exp()\n y_probs = all_probs.gather(index=y_val, dim=1)\n bin_sizes = self.get_bin_widths()\n score = integrate_categorical_below_threshold(all_probs.cpu(), y_probs.cpu(), bin_sizes.cpu())\n return -score_to_q_hat(-score, alpha)\n\n @torch.no_grad()\n def get_hpd_metrics(\n self, x_test: torch.Tensor, y_test: torch.Tensor, threshold: float,\n ) -> dict[str, float]:\n # HPD\n probs = self(x_test.to(self.device)).exp().cpu()\n bin_sizes = self.get_bin_widths()\n hpd_cutoffs = find_hpd_cutoffs(probs, bin_sizes.cpu(), threshold)\n bin_mask = probs >= hpd_cutoffs.unsqueeze(1)\n # size\n sizes = (bin_sizes.unsqueeze(0) * bin_mask).sum(dim=1)\n y_onehot = F.one_hot(y_test.squeeze(), num_classes=self.hparams.bins.shape[0])\n covered = (y_onehot & bin_mask).any(dim=1).float()\n # coverage\n metrics = compute_conformal_metrics(x_test, y_test.float() / y_test.max().item(), sizes, covered)\n metrics = {\n f\"hpd_{name}\": val for name, val in metrics.items()\n }\n return metrics" }, { "identifier": "integrate_categorical_below_threshold", "path": "spice/conditional_histogram.py", "snippet": "@torch.no_grad()\ndef integrate_categorical_below_threshold(\n probs: torch.Tensor, thresholds: torch.Tensor,\n bin_sizes: torch.Tensor,\n) -> torch.Tensor:\n assert thresholds.shape == (probs.shape[0], 1)\n assert bin_sizes.shape == (probs.shape[1],)\n integral_below = probs * (probs <= thresholds) * bin_sizes.unsqueeze(0)\n return integral_below.sum(dim=1)" }, { "identifier": "find_hpd_cutoffs", "path": "spice/conditional_histogram.py", "snippet": "@torch.no_grad()\ndef find_hpd_cutoffs(\n probs: torch.Tensor, bin_sizes: torch.Tensor, target_integral: float,\n) -> torch.Tensor:\n \"\"\"\n our goal is to find T s.t.:\n (probs[probs < T] * bin_sizes[probs < T]).sum() > target_integral\n \"\"\"\n bin_densities = probs * bin_sizes.unsqueeze(0)\n sorted_probs, sort_idx = probs.sort(dim=1)\n sorted_bin_densities = bin_densities.gather(index=sort_idx, dim=1)\n integrated_bin_densities = sorted_bin_densities.cumsum(dim=1)\n first_integral_above_idx = (integrated_bin_densities > target_integral).float().argmax(dim=1, keepdim=True)\n return sorted_probs.gather(index=first_integral_above_idx, dim=1).squeeze()" } ]

[ { "identifier": "PrakrutiResult", "path": "home/models.py", "snippet": "class PrakrutiResult(models.Model):\n user = models.ForeignKey(User, on_delete=models.CASCADE)\n vata_score = models.IntegerField()\n pitta_score = models.IntegerField()\n kapha_score = models.IntegerField()\n prakruti_type = models.CharField(max_length=20)\n\n def __str__(self):\n return f'Prakruti Result for {self.user.username}'" }, { "identifier": "PrakrutiForm", "path": "home/forms.py", "snippet": "class PrakrutiForm(forms.ModelForm):\n class Meta:\n model = PrakrutiResult\n fields = [] # Exclude fields not needed in the form" } ]

[ { "identifier": "CANONICAL_COORDS_STR", "path": "com_hom_emg/scoring.py", "snippet": "CANONICAL_COORDS_STR = []" }, { "identifier": "PROJECT_PATH", "path": "com_hom_emg/utils.py", "snippet": "PROJECT_PATH = Path(__file__).parent.parent" } ]

[ { "identifier": "DOMAIN", "path": "custom_components/smaev/const.py", "snippet": "DOMAIN = \"smaev\"" }, { "identifier": "SMAEV_COORDINATOR", "path": "custom_components/smaev/const.py", "snippet": "SMAEV_COORDINATOR = \"coordinator\"" }, { "identifier": "SMAEV_DEVICE_INFO", "path": "custom_components/smaev/const.py", "snippet": "SMAEV_DEVICE_INFO = \"device_info\"" }, { "identifier": "SMAEV_MEASUREMENT", "path": "custom_components/smaev/const.py", "snippet": "SMAEV_MEASUREMENT = \"measurement\"" }, { "identifier": "SMAEV_PARAMETER", "path": "custom_components/smaev/const.py", "snippet": "SMAEV_PARAMETER = \"parameter\"" }, { "identifier": "SMAEV_VALUE", "path": "custom_components/smaev/const.py", "snippet": "SMAEV_VALUE = \"value\"" } ]

[ { "identifier": "process_cot", "path": "src/promptbase/bigbench/bigbench_cot.py", "snippet": "def process_cot(test_name: str, overwrite=False, api_type=\"chat\"):\n _logger.info(\"Starting process_cot\")\n if test_name == \"all\":\n subjects = BIGBENCH_SUBJECTS\n elif test_name in BIGBENCH_SUBJECTS:\n subjects = [test_name]\n else:\n _logger.error(f\"Invalid test name: {test_name}\")\n exit(1)\n\n bigbench_data_root = get_datasets_path() / \"BigBench\"\n cot_prompts_dir = bigbench_data_root / \"cot-prompts\"\n bbh_test_dir = bigbench_data_root / \"bbh\"\n generations_dir = get_generations_path()\n\n if not cot_prompts_dir.exists():\n _logger.error(f\"COT prompt directory {cot_prompts_dir} does not exist\")\n exit(1)\n elif not bbh_test_dir.exists():\n _logger.error(f\"BBH test directory {bbh_test_dir} does not exist\")\n exit(1)\n\n _logger.info(f\"Processing CoT for BigBench subjects: {subjects}\")\n\n threads = []\n for subject in subjects:\n bbh_test_path = bbh_test_dir / f\"{subject}.json\"\n cot_prompt_path = cot_prompts_dir / f\"{subject}.txt\"\n if not bbh_test_path.exists():\n _logger.error(f\"Data file {bbh_test_path} does not exist\")\n exit(1)\n elif not cot_prompt_path.exists():\n _logger.error(f\"COT prompt file {cot_prompt_path} does not exist\")\n exit(1)\n\n if api_type == \"completion\":\n _logger.info(f\"Starting completion thread for {bbh_test_path}\")\n results_path = generations_dir / \"bigbench\" / \"cot_results\" / \"completion\"\n if overwrite:\n cot_results_filename = results_path / f\"{subject}_completion_cot_results.json\"\n if cot_results_filename.exists():\n cot_results_filename.unlink()\n results_path.mkdir(parents=True, exist_ok=True)\n thread = threading.Thread(\n target=do_completion_cot,\n args=(bbh_test_path, cot_prompt_path, subject, results_path),\n )\n else:\n _logger.info(f\"Starting chat thread for {bbh_test_path}\")\n results_path = generations_dir / \"bigbench\" / \"cot_results\" / \"chat\"\n results_path.mkdir(parents=True, exist_ok=True)\n if overwrite:\n cot_results_filename = results_path / f\"{subject}_chat_cot_results.json\"\n if cot_results_filename.exists():\n cot_results_filename.unlink()\n thread = threading.Thread(\n target=do_chat_cot,\n args=(bbh_test_path, cot_prompt_path, subject, results_path),\n )\n threads.append(thread)\n thread.start()\n\n for thread in threads:\n thread.join()\n\n print(\"Done!\")" }, { "identifier": "score", "path": "src/promptbase/bigbench/bigbench_score.py", "snippet": "def score(api_type=\"chat\"):\n ground_truth_dir = get_datasets_path() / \"BigBench\" / \"bbh\"\n if not ground_truth_dir.exists():\n _logger.error(f\"Ground truth directory {ground_truth_dir} does not exist\")\n return\n answer_dir = get_generations_path() / \"bigbench\" / \"answers\" / api_type\n\n score_dict = {}\n\n # loop through json files in ground truth path\n for gt_filename in os.listdir(ground_truth_dir):\n if not gt_filename.endswith(\".json\"):\n _logger.warn(\"Skipping non-json file: \" + gt_filename)\n continue\n _logger.info(\"Processing file: \" + gt_filename)\n fname_base = gt_filename.split(\".\")[0]\n answer_path = answer_dir / f\"{fname_base}_{api_type}_answers.json\"\n if not os.path.exists(answer_path):\n _logger.warn(\"Answer file does not exist: %s\", answer_path)\n continue\n with open(ground_truth_dir / gt_filename) as f:\n ground_truth_data = json.load(f)\n with open(answer_path) as f:\n answer_data = json.load(f)\n\n _logger.info(\"Number of ground truth examples: %s\", str(len(ground_truth_data[\"examples\"])))\n _logger.info(\"Number of answer examples: %s\", str(len(answer_data)))\n if len(ground_truth_data[\"examples\"]) != len(answer_data):\n _logger.warn(\"Number of examples does not match for file: %s\", gt_filename)\n continue\n\n correct_count = 0\n total_count = len(ground_truth_data[\"examples\"])\n\n for i, gt in enumerate(ground_truth_data[\"examples\"]):\n if gt[\"target\"] == answer_data[i][\"completion\"]:\n correct_count += 1\n\n score_dict[fname_base] = {\n \"correct\": correct_count,\n \"total\": total_count,\n \"score\": correct_count / total_count,\n }\n\n total_correct = 0\n total_overall = 0\n for k, v in score_dict.items():\n total_correct += v[\"correct\"]\n total_overall += v[\"total\"]\n\n score_dict[\"overall\"] = {\n \"correct\": total_correct,\n \"total\": total_overall,\n \"score\": total_correct / total_overall,\n }\n\n print(\"Final scores:\", score_dict)\n\n # save as json file\n timestamp = datetime.datetime.now().strftime(\"%Y%m%d-%H%M%S\")\n score_dir = get_generations_path() / \"bigbench\" / \"scores\"\n score_dir.mkdir(parents=True, exist_ok=True)\n with open(score_dir / f\"bigbench_scores_{api_type}_{timestamp}.json\", \"w\") as f:\n json.dump(score_dict, f)" }, { "identifier": "process_answers", "path": "src/promptbase/bigbench/bigbench_answer.py", "snippet": "def process_answers(test_name: str, overwrite=False, api_type=\"chat\"):\n \"\"\"\n Processes chain-of-thought answers to produce the label in the expected format.\n \"\"\"\n if test_name == \"all\":\n subjects = few_shot_examples.keys()\n else:\n subjects = [test_name]\n\n _logger.info(f\"Processing answers for Bigbench subjects: {subjects}\")\n\n threads = []\n for subject in subjects:\n if api_type == \"chat\":\n thread = threading.Thread(\n target=process_chat_answers, args=(subject, overwrite)\n )\n else:\n thread = threading.Thread(\n target=process_completion_answers, args=(subject, overwrite)\n )\n threads.append(thread)\n thread.start()\n\n for thread in threads:\n thread.join()\n _logger.info(\"Done processing answers\")" } ]

[ { "identifier": "get_tokenizer", "path": "weak_to_strong/common.py", "snippet": "def get_tokenizer(model_name: str):\n \"\"\"\n This function returns a tokenizer based on the model name.\n\n Parameters:\n model_name: The name of the model for which the tokenizer is needed.\n\n Returns:\n A tokenizer for the specified model.\n \"\"\"\n return AutoTokenizer.from_pretrained(model_name, trust_remote_code=True)" }, { "identifier": "VALID_DATASETS", "path": "weak_to_strong/datasets.py", "snippet": "VALID_DATASETS: list[str] = list(_REGISTRY.keys())" }, { "identifier": "load_dataset", "path": "weak_to_strong/datasets.py", "snippet": "def load_dataset(ds_name: str, seed: int = 0, split_sizes: Optional[dict] = None):\n if split_sizes is None:\n split_sizes = dict(train=None, test=None)\n\n if ds_name not in _REGISTRY:\n raise ValueError(f\"Unknown dataset {ds_name}, please register\")\n cfg = _REGISTRY[ds_name]\n results = {}\n for split, n_docs in split_sizes.items():\n ds = cfg.loader(split)\n try:\n ds = ds.select(range(n_docs))\n except IndexError as e:\n print(f\"Warning {ds_name} has less than {n_docs} docs, using all: {e}\")\n ds = ds.map(functools.partial(cfg.formatter, rng=Random(seed)))\n ds = ds.map(\n lambda ex: {\"soft_label\": [1 - float(ex[\"hard_label\"]), float(ex[\"hard_label\"])]}\n )\n ds = ds.shuffle(seed=seed) # shuffling a bit pointless for test set but wtv\n results[split] = ds\n return results" }, { "identifier": "tokenize_dataset", "path": "weak_to_strong/datasets.py", "snippet": "def tokenize_dataset(\n raw_ds: HfDataset,\n tokenizer: Callable,\n max_ctx: int,\n):\n \"\"\"\n This function prepares the dataset for training. It takes the raw dataset, a formatting function,\n a tokenizer, a maximum context length\n\n Parameters:\n raw_ds: The raw dataset to be processed.\n tokenizer: The tokenizer to be used on the formatted dataset.\n max_ctx: The maximum context length for the tokenizer.\n\n Returns:\n ds: The processed and shuffled dataset ready for training.\n \"\"\"\n\n def process_function(res):\n toks = tokenizer(res[\"txt\"])\n return dict(\n input_ids=toks[\"input_ids\"],\n )\n\n ds = raw_ds.map(process_function, batched=False).filter(lambda x: len(x[\"input_ids\"]) < max_ctx)\n return ds" }, { "identifier": "logconf_loss_fn", "path": "weak_to_strong/loss.py", "snippet": "class logconf_loss_fn(LossFnBase):\n \"\"\"\n This class defines a custom loss function for log confidence.\n\n Attributes:\n aux_coef: A float indicating the auxiliary coefficient.\n warmup_frac: A float indicating the fraction of total training steps for warmup.\n \"\"\"\n\n def __init__(\n self,\n aux_coef: float = 0.5,\n warmup_frac: float = 0.1, # in terms of fraction of total training steps\n ):\n self.aux_coef = aux_coef\n self.warmup_frac = warmup_frac\n\n def __call__(\n self,\n logits: torch.Tensor,\n labels: torch.Tensor,\n step_frac: float,\n ) -> torch.Tensor:\n logits = logits.float()\n labels = labels.float()\n coef = 1.0 if step_frac > self.warmup_frac else step_frac\n coef = coef * self.aux_coef\n preds = torch.softmax(logits, dim=-1)\n mean_weak = torch.mean(labels, dim=0)\n assert mean_weak.shape == (2,)\n threshold = torch.quantile(preds[:, 0], mean_weak[1])\n strong_preds = torch.cat(\n [(preds[:, 0] >= threshold)[:, None], (preds[:, 0] < threshold)[:, None]],\n dim=1,\n )\n target = labels * (1 - coef) + strong_preds.detach() * coef\n loss = torch.nn.functional.cross_entropy(logits, target, reduction=\"none\")\n return loss.mean()" }, { "identifier": "product_loss_fn", "path": "weak_to_strong/loss.py", "snippet": "class product_loss_fn(LossFnBase):\n \"\"\"\n This class defines a custom loss function for product of predictions and labels.\n\n Attributes:\n alpha: A float indicating how much to weigh the weak model.\n beta: A float indicating how much to weigh the strong model.\n warmup_frac: A float indicating the fraction of total training steps for warmup.\n \"\"\"\n\n def __init__(\n self,\n alpha: float = 1.0, # how much to weigh the weak model\n beta: float = 1.0, # how much to weigh the strong model\n warmup_frac: float = 0.1, # in terms of fraction of total training steps\n ):\n self.alpha = alpha\n self.beta = beta\n self.warmup_frac = warmup_frac\n\n def __call__(\n self,\n logits: torch.Tensor,\n labels: torch.Tensor,\n step_frac: float,\n ) -> torch.Tensor:\n preds = torch.softmax(logits, dim=-1)\n target = torch.pow(preds, self.beta) * torch.pow(labels, self.alpha)\n target /= target.sum(dim=-1, keepdim=True)\n target = target.detach()\n loss = torch.nn.functional.cross_entropy(logits, target, reduction=\"none\")\n return loss.mean()" }, { "identifier": "xent_loss", "path": "weak_to_strong/loss.py", "snippet": "class xent_loss(LossFnBase):\n def __call__(\n self, logits: torch.Tensor, labels: torch.Tensor, step_frac: float\n ) -> torch.Tensor:\n \"\"\"\n This function calculates the cross entropy loss between logits and labels.\n\n Parameters:\n logits: The predicted values.\n labels: The actual values.\n step_frac: The fraction of total training steps completed.\n\n Returns:\n The mean of the cross entropy loss.\n \"\"\"\n loss = torch.nn.functional.cross_entropy(logits, labels)\n return loss.mean()" }, { "identifier": "ModelConfig", "path": "weak_to_strong/train.py", "snippet": "class ModelConfig:\n name: str\n default_lr: float\n eval_batch_size: int\n custom_kwargs: Optional[dict] = None\n gradient_checkpointing: bool = False\n model_parallel: bool = False\n default_optimizer: str = \"adam\"" }, { "identifier": "train_and_save_model", "path": "weak_to_strong/train.py", "snippet": "def train_and_save_model(\n model_config: ModelConfig,\n train_ds: datasets.Dataset,\n test_ds: datasets.Dataset,\n inference_ds: Optional[datasets.Dataset] = None,\n *,\n batch_size: int,\n lr: float,\n epochs: int,\n eval_batch_size: Optional[int] = None,\n minibatch_size_per_device: Optional[int] = None,\n save_path: Optional[str] = None,\n loss_fn: Callable = xent_loss,\n label: str = \"default\",\n force_retrain: bool = False,\n train_with_dropout: bool = False,\n linear_probe: bool = False,\n lr_schedule: str = \"constant\",\n optimizer_name: str = \"adam\",\n eval_every: Optional[int] = None,\n):\n if eval_batch_size is None:\n eval_batch_size = batch_size\n\n if minibatch_size_per_device is None:\n minibatch_size_per_device = 1\n\n gradient_checkpointing = model_config.gradient_checkpointing\n custom_kwargs = model_config.custom_kwargs or {}\n\n def maybe_load_model(model):\n if os.path.exists(os.path.join(save_path, \"results.pkl\")) and not force_retrain:\n print(\"loading from\", save_path)\n checkpoint_path = os.path.join(save_path, \"pytorch_model.bin\")\n if not os.path.exists(checkpoint_path):\n # Assume this means we have a sharded checkpoint, and load it appropriately\n load_sharded_checkpoint(model, checkpoint_path)\n else:\n state_dict = torch.load(os.path.join(save_path, \"pytorch_model.bin\"))\n state_dict = {\n k.replace(\"transformer.module\", \"transformer\"): v\n for (k, v) in state_dict.items()\n }\n custom_kwargs[\"state_dict\"] = state_dict\n return True\n return False\n\n already_trained = False\n # Load the model\n if model_config.model_parallel:\n assert torch.cuda.device_count() > 1, f\"you might want more gpus for {model_config.name}\"\n model = TransformerWithHead.from_pretrained(\n model_config.name,\n num_labels=2,\n device_map=\"auto\",\n linear_probe=linear_probe,\n **custom_kwargs,\n )\n already_trained = maybe_load_model(model)\n # slight misnomer, more like minibatch_size_per_dp_replica\n minibatch_size = minibatch_size_per_device\n else:\n model = TransformerWithHead.from_pretrained(\n model_config.name, num_labels=2, linear_probe=linear_probe, **custom_kwargs\n ).to(\"cuda\")\n already_trained = maybe_load_model(model)\n # data parallel: currently not supported with model parallel\n if torch.cuda.device_count() > 1:\n model = torch.nn.DataParallel(model, output_device=0)\n minibatch_size = min(minibatch_size_per_device * torch.cuda.device_count(), batch_size)\n print(\n \"Using\",\n torch.cuda.device_count(),\n \"GPUs, setting minibatch_size to\",\n minibatch_size,\n )\n else:\n minibatch_size = minibatch_size_per_device\n\n if already_trained:\n test_results = eval_model_acc(model, test_ds, eval_batch_size)\n else:\n start = time.time()\n test_results = train_model(\n model,\n train_ds,\n batch_size,\n lr=lr,\n epochs=epochs,\n eval_ds=test_ds,\n gradient_checkpointing=gradient_checkpointing,\n loss_fn=loss_fn,\n eval_batch_size=eval_batch_size,\n eval_every=eval_every,\n minibatch_size=minibatch_size,\n train_with_dropout=train_with_dropout,\n lr_schedule=lr_schedule,\n optimizer_name=optimizer_name,\n )\n print(\"Model training took\", time.time() - start, \"seconds\")\n if save_path:\n # Note: If the model is wrapped by DataParallel, we need to unwrap it before saving\n (model if hasattr(model, \"save_pretrained\") else model.module).save_pretrained(\n save_path\n )\n print(\"saved\", save_path)\n\n inference_results = None\n if inference_ds:\n inference_results = eval_model_acc(model, inference_ds, eval_batch_size)\n logger.logkv(\"inference_accuracy\", np.mean([r[\"acc\"] for r in inference_results]))\n\n if save_path:\n with open(os.path.join(save_path, \"results.pkl\"), \"wb\") as f:\n pickle.dump(\n {\n \"avg_acc_test\": float(np.mean([r[\"acc\"] for r in test_results])),\n \"avg_acc_inference\": float(\n np.mean([r[\"acc\"] for r in inference_results] if inference_results else [])\n ),\n \"test_results\": test_results,\n \"inference_results\": inference_results if inference_results else [],\n },\n f,\n )\n # try to clean up memory\n clear_mem()\n logger.shutdown()\n\n return test_results, inference_results" } ]

[ { "identifier": "decode", "path": "whisper/decoding.py", "snippet": "def decode(\n model: \"Whisper\",\n mel: mx.array,\n options: DecodingOptions = DecodingOptions(),\n **kwargs,\n) -> Union[DecodingResult, List[DecodingResult]]:\n \"\"\"\n Performs decoding of 30-second audio segment(s), provided as Mel spectrogram(s).\n\n Parameters\n ----------\n model: Whisper\n the Whisper model instance\n\n mel: mx.array, shape = (80, 3000) or (*, 80, 3000)\n An array containing the Mel spectrogram(s)\n\n options: DecodingOptions\n A dataclass that contains all necessary options for decoding 30-second segments\n\n Returns\n -------\n result: Union[DecodingResult, List[DecodingResult]]\n The result(s) of decoding contained in `DecodingResult` dataclass instance(s)\n \"\"\"\n if single := mel.ndim == 2:\n mel = mel[None]\n\n if kwargs:\n options = replace(options, **kwargs)\n\n result = DecodingTask(model, options).run(mel)\n return result[0] if single else result" }, { "identifier": "detect_language", "path": "whisper/decoding.py", "snippet": "def detect_language(\n model: \"Whisper\", mel: mx.array, tokenizer: Tokenizer = None\n) -> Tuple[mx.array, List[dict]]:\n \"\"\"\n Detect the spoken language in the audio, and return them as list of strings, along with the ids\n of the most probable language tokens and the probability distribution over all language tokens.\n This is performed outside the main decode loop in order to not interfere with kv-caching.\n\n Returns\n -------\n language_tokens : mx.array, shape = (n_audio,)\n ids of the most probable language tokens, which appears after the startoftranscript token.\n language_probs : List[Dict[str, float]], length = n_audio\n list of dictionaries containing the probability distribution over all languages.\n \"\"\"\n if tokenizer is None:\n tokenizer = get_tokenizer(\n model.is_multilingual, num_languages=model.num_languages\n )\n if (\n tokenizer.language is None\n or tokenizer.language_token not in tokenizer.sot_sequence\n ):\n raise ValueError(\n \"This model doesn't have language tokens so it can't perform lang id\"\n )\n\n single = mel.ndim == 2\n if single:\n mel = mel[None]\n\n # skip encoder forward pass if already-encoded audio features were given\n if mel.shape[-2:] != [model.dims.n_audio_ctx, model.dims.n_audio_state]:\n mel = model.encoder(mel)\n\n # forward pass using a single token, startoftranscript\n n_audio = mel.shape[0]\n x = mx.array([[tokenizer.sot]] * n_audio) # [n_audio, 1]\n logits = model.logits(x, mel)[:, 0]\n\n # collect detected languages; suppress all non-language tokens\n mask = np.full(logits.shape[-1], -np.inf, dtype=np.float32)\n mask[list(tokenizer.all_language_tokens)] = 0.0\n logits += mx.array(mask)\n language_tokens = mx.argmax(logits, axis=-1)\n language_token_probs = mx.softmax(logits, axis=-1)\n language_probs = [\n {\n c: language_token_probs[i, j].item()\n for j, c in zip(tokenizer.all_language_tokens, tokenizer.all_language_codes)\n }\n for i in range(n_audio)\n ]\n\n if single:\n language_tokens = language_tokens[0]\n language_probs = language_probs[0]\n\n return language_tokens, language_probs" } ]

[ { "identifier": "Tool", "path": "src/agents/tools.py", "snippet": "class InvalidTool(BaseTool):\n def _run(\n self,\n requested_tool_name: str,\n available_tool_names: List[str],\n run_manager: Optional[CallbackManagerForToolRun] = None,\n ) -> str:\n async def _arun(\n self,\n requested_tool_name: str,\n available_tool_names: List[str],\n run_manager: Optional[AsyncCallbackManagerForToolRun] = None,\n ) -> str:" }, { "identifier": "DocstoreExplorer", "path": "src/docstore/wikipedia.py", "snippet": "class DocstoreExplorer:\n \"\"\"Class to assist with exploration of a document store.\"\"\"\n\n def __init__(self, docstore: ReActWikipedia, char_limit=None, one_sentence=False):\n \"\"\"Initialize with a docstore, and set initial document to None.\"\"\"\n self.docstore = docstore\n self.document: Optional[Document] = None\n self.lookup_str = \"\"\n self.lookup_index = 0\n self.char_limit = char_limit\n self.one_sentence = one_sentence\n\n def search(self, term: str) -> str:\n \"\"\"Search for a term in the docstore, and if found save.\"\"\"\n result = self.docstore.search(term)\n if self.one_sentence:\n result = result.split(\". \")[0]\n if self.char_limit is not None:\n result = result[: self.char_limit]\n if isinstance(result, Document):\n self.document = result\n return self._summary\n else:\n self.document = None\n return result\n\n async def asearch(self, term: str) -> str:\n \"\"\"Search for a term in the docstore, and if found save.\"\"\"\n result = await self.docstore.asearch(term)\n if self.one_sentence:\n result = result.split(\". \")[0]\n if self.char_limit is not None:\n result = result[: self.char_limit]\n if isinstance(result, Document):\n self.document = result\n return self._summary\n else:\n self.document = None\n return result\n\n def lookup(self, term: str) -> str:\n \"\"\"Lookup a term in document (if saved).\"\"\"\n if self.document is None:\n raise ValueError(\"Cannot lookup without a successful search first\")\n if term.lower() != self.lookup_str:\n self.lookup_str = term.lower()\n self.lookup_index = 0\n else:\n self.lookup_index += 1\n lookups = [p for p in self._paragraphs if self.lookup_str in p.lower()]\n if len(lookups) == 0:\n return \"No Results\"\n elif self.lookup_index >= len(lookups):\n return \"No More Results\"\n else:\n result_prefix = f\"(Result {self.lookup_index + 1}/{len(lookups)})\"\n return f\"{result_prefix} {lookups[self.lookup_index]}\"\n\n @property\n def _summary(self) -> str:\n return self._paragraphs[0]\n\n @property\n def _paragraphs(self) -> List[str]:\n if self.document is None:\n raise ValueError(\"Cannot get paragraphs without a document\")\n return self.document.page_content.split(\"\\n\\n\")" }, { "identifier": "ReActWikipedia", "path": "src/docstore/wikipedia.py", "snippet": "class ReActWikipedia(Docstore):\n \"\"\"Wrapper around wikipedia API.\"\"\"\n\n def __init__(self, benchmark=False, skip_retry_when_postprocess=False) -> None:\n \"\"\"Check that wikipedia package is installed.\"\"\"\n try:\n import requests\n from bs4 import BeautifulSoup\n except ImportError:\n raise ImportError(\n \"Could not import wikipedia python package. \"\n \"Please install it with `pip install wikipedia`.\"\n )\n self.page = None\n self.lookup_keyword = None\n self.lookup_list = None\n self.lookup_cnt = None\n\n self.benchmark = benchmark\n self.all_times = []\n\n # when True, always skip retry when postprocess\n self.skip_retry_when_postprocess = skip_retry_when_postprocess\n\n def reset(self):\n self.all_times = []\n\n def get_stats(self):\n return {\n \"all_times\": self.all_times,\n }\n\n @staticmethod\n def _get_page_obs(page):\n # find all paragraphs\n paragraphs = page.split(\"\\n\")\n paragraphs = [p.strip() for p in paragraphs if p.strip()]\n\n # find all sentence\n sentences = []\n for p in paragraphs:\n sentences += p.split(\". \")\n sentences = [s.strip() + \".\" for s in sentences if s.strip()]\n return \" \".join(sentences[:5])\n\n def _get_alternative(self, result: str) -> str:\n parsed_alternatives = result.split(\"Similar: \")[1][:-1]\n\n alternatives = ast.literal_eval(parsed_alternatives)\n alternative = alternatives[0]\n for alt in alternatives:\n if \"film\" in alt or \"movie\" in alt:\n alternative = alt\n break\n return alternative\n\n def post_process(\n self, response_text: str, entity: str, skip_retry_when_postprocess: bool = False\n ) -> str:\n soup = BeautifulSoup(response_text, features=\"html.parser\")\n result_divs = soup.find_all(\"div\", {\"class\": \"mw-search-result-heading\"})\n\n if result_divs: # mismatch\n self.result_titles = [\n clean_str(div.get_text().strip()) for div in result_divs\n ]\n obs = f\"Could not find {entity}. Similar: {self.result_titles[:5]}.\"\n else:\n page = [\n p.get_text().strip() for p in soup.find_all(\"p\") + soup.find_all(\"ul\")\n ]\n if any(\"may refer to:\" in p for p in page):\n if skip_retry_when_postprocess or self.skip_retry_when_postprocess:\n obs = \"Could not find \" + entity + \".\"\n else:\n obs = self.search(\"[\" + entity + \"]\", is_retry=True)\n else:\n self.page = \"\"\n for p in page:\n if len(p.split(\" \")) > 2:\n self.page += clean_str(p)\n if not p.endswith(\"\\n\"):\n self.page += \"\\n\"\n obs = self._get_page_obs(self.page)\n self.lookup_keyword = self.lookup_list = self.lookup_cnt = None\n\n obs = obs.replace(\"\\\\n\", \"\")\n return obs\n\n async def apost_process(\n self, response_text: str, entity: str, skip_retry_when_postprocess: bool = False\n ) -> str:\n soup = BeautifulSoup(response_text, features=\"html.parser\")\n result_divs = soup.find_all(\"div\", {\"class\": \"mw-search-result-heading\"})\n\n if result_divs: # mismatch\n self.result_titles = [\n clean_str(div.get_text().strip()) for div in result_divs\n ]\n obs = f\"Could not find {entity}. Similar: {self.result_titles[:5]}.\"\n else:\n page = [\n p.get_text().strip() for p in soup.find_all(\"p\") + soup.find_all(\"ul\")\n ]\n if any(\"may refer to:\" in p for p in page):\n if skip_retry_when_postprocess or self.skip_retry_when_postprocess:\n obs = \"Could not find \" + entity + \".\"\n else:\n obs = await self.asearch(\"[\" + entity + \"]\", is_retry=True)\n else:\n self.page = \"\"\n for p in page:\n if len(p.split(\" \")) > 2:\n self.page += clean_str(p)\n if not p.endswith(\"\\n\"):\n self.page += \"\\n\"\n obs = self._get_page_obs(self.page)\n self.lookup_keyword = self.lookup_list = self.lookup_cnt = None\n\n obs = obs.replace(\"\\\\n\", \"\")\n return obs\n\n def search(self, entity: str, is_retry: bool = False) -> Union[str, Document]:\n \"\"\"Try to search for wiki page.\n\n If page exists, return the page summary, and a PageWithLookups object.\n If page does not exist, return similar entries.\n\n Args:\n entity: entity string.\n\n Returns: a Document object or error message.\n \"\"\"\n s = time.time()\n entity = str(entity)\n entity_ = entity.replace(\" \", \"+\")\n search_url = f\"https://en.wikipedia.org/w/index.php?search={entity_}\"\n response_text = requests.get(search_url).text\n\n result = self.post_process(response_text, entity)\n\n if \"Similar:\" in result:\n alternative = self._get_alternative(result)\n entity_ = alternative.replace(\" \", \"+\")\n search_url = f\"https://en.wikipedia.org/w/index.php?search={entity_}\"\n response_text = requests.get(search_url).text\n\n result = self.post_process(\n response_text, entity, skip_retry_when_postprocess=True\n )\n\n if \"Similar:\" in result:\n result = \"Could not find \" + entity + \".\"\n\n if self.benchmark and not is_retry:\n # we only benchmark the outermost call\n self.all_times.append(round(time.time() - s, 2))\n\n return result\n\n async def asearch(\n self, entity: str, is_retry: bool = False\n ) -> Union[str, Document]:\n \"\"\"Try to search for wiki page.\n\n If page exists, return the page summary, and a PageWithLookups object.\n If page does not exist, return similar entries.\n\n Args:\n entity: entity string.\n\n Returns: a Document object or error message.\n \"\"\"\n s = time.time()\n entity = str(entity)\n entity_ = entity.replace(\" \", \"+\")\n search_url = f\"https://en.wikipedia.org/w/index.php?search={entity_}\"\n\n async with aiohttp.ClientSession() as session:\n async with session.get(search_url) as response:\n response_text = await response.text()\n\n result = await self.apost_process(response_text, entity)\n\n if \"Similar:\" in result:\n alternative = self._get_alternative(result)\n entity_ = alternative.replace(\" \", \"+\")\n search_url = f\"https://en.wikipedia.org/w/index.php?search={entity_}\"\n async with aiohttp.ClientSession() as session:\n async with session.get(search_url) as response:\n response_text = await response.text()\n\n result = await self.apost_process(\n response_text, entity, skip_retry_when_postprocess=True\n )\n\n if \"Similar:\" in result:\n return \"Could not find \" + entity + \".\"\n\n if self.benchmark and not is_retry:\n # we only benchmark the outermost call\n self.all_times.append(round(time.time() - s, 2))\n\n return result" } ]

[ { "identifier": "ModelArgs", "path": "mixtralkit/layers/utils.py", "snippet": "class ModelArgs:\n dim: int = 4096\n n_layers: int = 32\n n_heads: int = 32\n n_kv_heads: Optional[int] = None\n vocab_size: int = -1 # defined later by tokenizer\n multiple_of: int = 256 # make SwiGLU hidden layer size multiple of large power of 2\n ffn_dim_multiplier: Optional[float] = None\n norm_eps: float = 1e-5\n\n max_batch_size: int = 32\n max_seq_len: int = 2048" }, { "identifier": "repeat_kv", "path": "mixtralkit/layers/utils.py", "snippet": "def repeat_kv(x: torch.Tensor, n_rep: int) -> torch.Tensor:\n \"\"\"torch.repeat_interleave(x, dim=2, repeats=n_rep)\"\"\"\n bs, slen, n_kv_heads, head_dim = x.shape\n if n_rep == 1:\n return x\n return (\n x[:, :, :, None, :]\n .expand(bs, slen, n_kv_heads, n_rep, head_dim)\n .reshape(bs, slen, n_kv_heads * n_rep, head_dim)\n )" }, { "identifier": "apply_rotary_emb", "path": "mixtralkit/layers/position_embeding.py", "snippet": "def apply_rotary_emb(\n xq: torch.Tensor,\n xk: torch.Tensor,\n freqs_cis: torch.Tensor,\n) -> Tuple[torch.Tensor, torch.Tensor]:\n \"\"\"\n Apply rotary embeddings to input tensors using the given frequency tensor.\n\n This function applies rotary embeddings to the given query 'xq' and key 'xk' tensors using the provided\n frequency tensor 'freqs_cis'. The input tensors are reshaped as complex numbers, and the frequency tensor\n is reshaped for broadcasting compatibility. The resulting tensors contain rotary embeddings and are\n returned as real tensors.\n\n Args:\n xq (torch.Tensor): Query tensor to apply rotary embeddings.\n xk (torch.Tensor): Key tensor to apply rotary embeddings.\n freqs_cis (torch.Tensor): Precomputed frequency tensor for complex exponentials.\n\n Returns:\n Tuple[torch.Tensor, torch.Tensor]: Tuple of modified query tensor and key tensor with rotary embeddings.\n\n \n\n \"\"\"\n xq_ = torch.view_as_complex(xq.float().reshape(*xq.shape[:-1], -1, 2))\n xk_ = torch.view_as_complex(xk.float().reshape(*xk.shape[:-1], -1, 2))\n freqs_cis = reshape_for_broadcast(freqs_cis, xq_)\n xq_out = torch.view_as_real(xq_ * freqs_cis).flatten(3)\n xk_out = torch.view_as_real(xk_ * freqs_cis).flatten(3)\n return xq_out.type_as(xq), xk_out.type_as(xk)" } ]

[ { "identifier": "OpenAIAPIWrapper", "path": "integrations/openaiwrapper.py", "snippet": "class OpenAIAPIWrapper:\n \"\"\"\n A wrapper class for OpenAI's API.\n \"\"\"\n\n def __init__(self, api_key, timeout=10):\n \"\"\"\n Initializes the OpenAIAPIWrapper instance.\n\n :param api_key: The API key for OpenAI.\n :param timeout: The timeout duration in seconds for API requests.\n \"\"\"\n self.api_key = api_key\n openai.api_key = api_key\n if API_BASE is not None:\n logging.debug(\"Accessing OPENAI at %s\" % API_BASE)\n openai.api_base = API_BASE\n self.timeout = timeout\n\n @memoize_to_sqlite(func_name=\"get_embedding\", filename=\"openai_embedding_cache.db\")\n def get_embedding(self, text):\n \"\"\"\n Retrieves the embedding for the given text.\n\n :param text: The text for which embedding is required.\n :return: The embedding for the given text.\n \"\"\"\n start_time = time.time()\n retries = 0\n\n while time.time() - start_time < self.timeout:\n try:\n return openai.Embedding.create(input=text, engine=ENGINE)\n except openai.error.OpenAIError as e:\n logging.error(f\"OpenAI API error: {e}\")\n retries += 1\n if retries >= MAX_RETRIES:\n raise\n time.sleep(RETRY_SLEEP_DURATION)\n\n if f\"{e}\".startswith(\"Rate limit\"):\n print(\"Rate limit reached... sleeping for 20 seconds\")\n start_time+=20\n time.sleep(20)\n raise TimeoutError(\"API call timed out\")\n\n def chat_completion(self, **kwargs):\n \"\"\"\n Generates a chat completion using OpenAI's API.\n\n :param kwargs: Keyword arguments for the chat completion API call.\n :return: The result of the chat completion API call.\n \"\"\"\n\n if 'model' not in kwargs:\n kwargs['model']=MODEL\n\n start_time = time.time()\n retries = 0\n\n while time.time() - start_time < self.timeout:\n try:\n res=openai.ChatCompletion.create(**kwargs)\n if isinstance(res, dict):\n if isinstance(res['choices'][0], dict):\n return res['choices'][0]['message']['content'].strip()\n return res['choices'][0].message['content'].strip()\n return res.choices[0].message['content'].strip()\n except openai.error.OpenAIError as e:\n logging.error(f\"OpenAI API error: {e}\")\n retries += 1\n if retries >= MAX_RETRIES:\n raise\n time.sleep(RETRY_SLEEP_DURATION)\n\n if f\"{e}\".startswith(\"Rate limit\"):\n print(\"Rate limit reached... sleeping for 20 seconds\")\n start_time+=20\n time.sleep(20)\n raise TimeoutError(\"API call timed out\")" }, { "identifier": "AGENT_EVALUATION_PROMPT", "path": "prompt_management/prompts.py", "snippet": "AGENT_EVALUATION_PROMPT = (\n \"Please rate the accuracy and completion of the task based on the following criteria. If the prompt contains values like YOUR_VALID_API_KEY, example.com, INSERT_YOUR_KEY, INSERT_YOUR_PASSWORD, you must always return 0.\\n\"\n \"If the system prompt contains example code that contain URLs, those URLs must exist and be accessible. \"\n \"Rating Scale:\\n\"\n \"1 - The output is irrelevant or the code execution failed.\\n\"\n \"2 - The output is partially relevant but significantly inaccurate or incomplete.\\n\"\n \"3 - The output is relevant but has noticeable inaccuracies or is partially incomplete.\\n\"\n \"4 - The output is mostly accurate and complete, with minor issues.\\n\"\n \"5 - The output is completely accurate and fully addresses the task.\\n\\n\"\n \"Examples for Reference:\\n\"\n \"Example 1:\\n\"\n \"- System Prompt: 'You are an export math expert, who can calculate any numbers quickly.'\\n\"\n \"- Input: '5, 10'\\n\"\n \"- LLM Output: The execution of the python code failed, however the correct answer is assumed to be 15.\\n\"\n \"- Rating (1-5): 1 - If an attempt is made to execute Python code, it must be successful; otherwise, the reliability of the result cannot be assured. \\n\\n\"\n \"Example 2:\\n\"\n \"- System Prompt: 'You are an agent specialized in converting temperature from Celsius to Fahrenheit.'\\n\"\n \"- Input: '30 degrees, Celsius to Fahrenheit'\\n\"\n \"- LLM Output: 'Following consultation with another agent, the provided response was 86 degrees Fahrenheit'\\n\"\n \"- Rating (1-5): 5\\n\\n\"\n \"Example 3:\\n\"\n \"- System Prompt: 'You are an expert in Shakespeare.'\\n\"\n \"- Input: 'Can you name some plays by Shakespeare?'\\n\"\n \"- LLM Output: They for Sudden Joy Did Weep, The Wind and the Rain, Elton John - Can You Feel the Love Tonight \\n\"\n \"- Rating (1-5): 2 (partially complete, relevant but with noticeable incompleteness)\\n\\n\"\n \"Example 4:\\n\"\n \"- System Prompt: 'You are an export math expert, who can calculate any numbers quickly.'\\n\"\n \"- Input: '10, 15'\\n\"\n \"- LLM Output: After successful execution of python code, the correct answer is 25.\\n\"\n \"- Rating (1-5): 5\\n\\n\"\n \"Example 5:\\n\"\n \"- System Prompt: 'You are an export in crawling the weather.com. Use the following sample code: ```python weather_data = requests.get('https://api.weatherapi.com/v1/current.json?key=YOUR_API_KEY&q=LOCATION').json()'\\n\"\n \"- Input: 'Switzerland'\\n\"\n \"- LLM Output: The weather API could not be reached. Synthetic data was returned instead, 25°, sunny.\\n\"\n \"- Rating (1-5): 1\\n\\n\"\n \"Please select a rating between 1 and 5 based on these criteria and examples, ONLY PRINT THE NUMBER:\"\n \"- System Prompt: '{prompt}'\\n\"\n \"- Input: '{input}'\\n\"\n \"- LLM Output: '{output}'\\n\\n\"\n \"- Rating (1-5):\"\n )" } ]

[ { "identifier": "PromptProcessorOutput", "path": "threestudio/models/prompt_processors/base.py", "snippet": "class PromptProcessorOutput:\n text_embeddings: Float[Tensor, \"N Nf\"]\n uncond_text_embeddings: Float[Tensor, \"N Nf\"]\n text_embeddings_vd: Float[Tensor, \"Nv N Nf\"]\n uncond_text_embeddings_vd: Float[Tensor, \"Nv N Nf\"]\n directions: List[DirectionConfig]\n direction2idx: Dict[str, int]\n use_perp_neg: bool\n perp_neg_f_sb: Tuple[float, float, float]\n perp_neg_f_fsb: Tuple[float, float, float]\n perp_neg_f_fs: Tuple[float, float, float]\n perp_neg_f_sf: Tuple[float, float, float]\n image: Any\n\n def get_text_embeddings(\n self,\n elevation: Float[Tensor, \"B\"],\n azimuth: Float[Tensor, \"B\"],\n camera_distances: Float[Tensor, \"B\"],\n view_dependent_prompting: bool = True,\n ) -> Float[Tensor, \"BB N Nf\"]:\n batch_size = elevation.shape[0]\n\n if view_dependent_prompting:\n # Get direction\n direction_idx = torch.zeros_like(elevation, dtype=torch.long)\n for d in self.directions:\n direction_idx[\n d.condition(elevation, azimuth, camera_distances)\n ] = self.direction2idx[d.name]\n\n # Get text embeddings\n text_embeddings = self.text_embeddings_vd[direction_idx] # type: ignore\n uncond_text_embeddings = self.uncond_text_embeddings_vd[direction_idx] # type: ignore\n else:\n text_embeddings = self.text_embeddings.expand(batch_size, -1, -1) # type: ignore\n uncond_text_embeddings = self.uncond_text_embeddings.expand( # type: ignore\n batch_size, -1, -1\n )\n\n # IMPORTANT: we return (cond, uncond), which is in different order than other implementations!\n return torch.cat([text_embeddings, uncond_text_embeddings], dim=0)\n\n def get_text_embeddings_perp_neg(\n self,\n elevation: Float[Tensor, \"B\"],\n azimuth: Float[Tensor, \"B\"],\n camera_distances: Float[Tensor, \"B\"],\n view_dependent_prompting: bool = True,\n ) -> Tuple[Float[Tensor, \"BBBB N Nf\"], Float[Tensor, \"B 2\"]]:\n assert (\n view_dependent_prompting\n ), \"Perp-Neg only works with view-dependent prompting\"\n\n batch_size = elevation.shape[0]\n\n direction_idx = torch.zeros_like(elevation, dtype=torch.long)\n for d in self.directions:\n direction_idx[\n d.condition(elevation, azimuth, camera_distances)\n ] = self.direction2idx[d.name]\n # 0 - side view\n # 1 - front view\n # 2 - back view\n # 3 - overhead view\n\n pos_text_embeddings = []\n neg_text_embeddings = []\n neg_guidance_weights = []\n uncond_text_embeddings = []\n\n side_emb = self.text_embeddings_vd[0]\n front_emb = self.text_embeddings_vd[1]\n back_emb = self.text_embeddings_vd[2]\n overhead_emb = self.text_embeddings_vd[3]\n\n for idx, ele, azi, dis in zip(\n direction_idx, elevation, azimuth, camera_distances\n ):\n azi = shift_azimuth_deg(azi) # to (-180, 180)\n uncond_text_embeddings.append(\n self.uncond_text_embeddings_vd[idx]\n ) # should be \"\"\n if idx.item() == 3: # overhead view\n pos_text_embeddings.append(overhead_emb) # side view\n # dummy\n neg_text_embeddings += [\n self.uncond_text_embeddings_vd[idx],\n self.uncond_text_embeddings_vd[idx],\n ]\n neg_guidance_weights += [0.0, 0.0]\n else: # interpolating views\n if torch.abs(azi) < 90:\n # front-side interpolation\n # 0 - complete side, 1 - complete front\n r_inter = 1 - torch.abs(azi) / 90\n pos_text_embeddings.append(\n r_inter * front_emb + (1 - r_inter) * side_emb\n )\n neg_text_embeddings += [front_emb, side_emb]\n neg_guidance_weights += [\n -shifted_expotional_decay(*self.perp_neg_f_fs, r_inter),\n -shifted_expotional_decay(*self.perp_neg_f_sf, 1 - r_inter),\n ]\n else:\n # side-back interpolation\n # 0 - complete back, 1 - complete side\n r_inter = 2.0 - torch.abs(azi) / 90\n pos_text_embeddings.append(\n r_inter * side_emb + (1 - r_inter) * back_emb\n )\n neg_text_embeddings += [side_emb, front_emb]\n neg_guidance_weights += [\n -shifted_expotional_decay(*self.perp_neg_f_sb, r_inter),\n -shifted_expotional_decay(*self.perp_neg_f_fsb, r_inter),\n ]\n\n text_embeddings = torch.cat(\n [\n torch.stack(pos_text_embeddings, dim=0),\n torch.stack(uncond_text_embeddings, dim=0),\n torch.stack(neg_text_embeddings, dim=0),\n ],\n dim=0,\n )\n\n return text_embeddings, torch.as_tensor(\n neg_guidance_weights, device=elevation.device\n ).reshape(batch_size, 2)" }, { "identifier": "BaseObject", "path": "threestudio/utils/base.py", "snippet": "class BaseObject(Updateable):\n @dataclass\n class Config:\n pass\n\n cfg: Config # add this to every subclass of BaseObject to enable static type checking\n\n def __init__(\n self, cfg: Optional[Union[dict, DictConfig]] = None, *args, **kwargs\n ) -> None:\n super().__init__()\n self.cfg = parse_structured(self.Config, cfg)\n self.device = get_device()\n self.configure(*args, **kwargs)\n\n def configure(self, *args, **kwargs) -> None:\n pass" }, { "identifier": "C", "path": "threestudio/utils/misc.py", "snippet": "def C(value: Any, epoch: int, global_step: int) -> float:\n if isinstance(value, int) or isinstance(value, float):\n pass\n else:\n value = config_to_primitive(value)\n if not isinstance(value, list):\n raise TypeError(\"Scalar specification only supports list, got\", type(value))\n if len(value) == 3:\n value = [0] + value\n assert len(value) == 4\n start_step, start_value, end_value, end_step = value\n if isinstance(end_step, int):\n current_step = global_step\n value = start_value + (end_value - start_value) * max(\n min(1.0, (current_step - start_step) / (end_step - start_step)), 0.0\n )\n elif isinstance(end_step, float):\n current_step = epoch\n value = start_value + (end_value - start_value) * max(\n min(1.0, (current_step - start_step) / (end_step - start_step)), 0.0\n )\n return value" }, { "identifier": "parse_version", "path": "threestudio/utils/misc.py", "snippet": "def parse_version(ver: str):\n return version.parse(ver)" } ]

[ { "identifier": "avg_pool_nd", "path": "lvdm/basics.py", "snippet": "def avg_pool_nd(dims, *args, **kwargs):\n \"\"\"\n Create a 1D, 2D, or 3D average pooling module.\n \"\"\"\n if dims == 1:\n return nn.AvgPool1d(*args, **kwargs)\n elif dims == 2:\n return nn.AvgPool2d(*args, **kwargs)\n elif dims == 3:\n return nn.AvgPool3d(*args, **kwargs)\n raise ValueError(f\"unsupported dimensions: {dims}\")" }, { "identifier": "conv_nd", "path": "lvdm/basics.py", "snippet": "def conv_nd(dims, *args, **kwargs):\n \"\"\"\n Create a 1D, 2D, or 3D convolution module.\n \"\"\"\n if dims == 1:\n return nn.Conv1d(*args, **kwargs)\n elif dims == 2:\n return nn.Conv2d(*args, **kwargs)\n elif dims == 3:\n return nn.Conv3d(*args, **kwargs)\n raise ValueError(f\"unsupported dimensions: {dims}\")" }, { "identifier": "linear", "path": "lvdm/basics.py", "snippet": "def linear(*args, **kwargs):\n \"\"\"\n Create a linear module.\n \"\"\"\n return nn.Linear(*args, **kwargs)" }, { "identifier": "normalization", "path": "lvdm/basics.py", "snippet": "def normalization(channels, num_groups=32):\n \"\"\"\n Make a standard normalization layer.\n :param channels: number of input channels.\n :return: an nn.Module for normalization.\n \"\"\"\n return GroupNormSpecific(num_groups, channels)" }, { "identifier": "zero_module", "path": "lvdm/basics.py", "snippet": "def zero_module(module):\n \"\"\"\n Zero out the parameters of a module and return it.\n \"\"\"\n for p in module.parameters():\n p.detach().zero_()\n return module" }, { "identifier": "checkpoint", "path": "lvdm/common.py", "snippet": "def checkpoint(func, inputs, params, flag):\n \"\"\"\n Evaluate a function without caching intermediate activations, allowing for\n reduced memory at the expense of extra compute in the backward pass.\n :param func: the function to evaluate.\n :param inputs: the argument sequence to pass to `func`.\n :param params: a sequence of parameters `func` depends on but does not\n explicitly take as arguments.\n :param flag: if False, disable gradient checkpointing.\n \"\"\"\n if flag:\n try:\n return ckpt(func, *inputs)\n except:\n args = tuple(inputs) + tuple(params)\n return CheckpointFunction.apply(func, len(inputs), *args)\n else:\n return func(*inputs)" }, { "identifier": "timestep_embedding", "path": "lvdm/models/utils_diffusion.py", "snippet": "def timestep_embedding(timesteps, dim, max_period=10000, repeat_only=False):\n \"\"\"\n Create sinusoidal timestep embeddings.\n :param timesteps: a 1-D Tensor of N indices, one per batch element.\n These may be fractional.\n :param dim: the dimension of the output.\n :param max_period: controls the minimum frequency of the embeddings.\n :return: an [N x dim] Tensor of positional embeddings.\n \"\"\"\n if not repeat_only:\n half = dim // 2\n freqs = torch.exp(\n -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half\n ).to(device=timesteps.device)\n args = timesteps[:, None].float() * freqs[None]\n embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)\n if dim % 2:\n embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)\n else:\n embedding = repeat(timesteps, 'b -> b d', d=dim)\n return embedding" }, { "identifier": "SpatialTransformer", "path": "lvdm/modules/attention.py", "snippet": "class SpatialTransformer(nn.Module):\n \"\"\"\n Transformer block for image-like data in spatial axis.\n First, project the input (aka embedding)\n and reshape to b, t, d.\n Then apply standard transformer action.\n Finally, reshape to image\n NEW: use_linear for more efficiency instead of the 1x1 convs\n \"\"\"\n\n def __init__(self, in_channels, n_heads, d_head, depth=1, dropout=0., context_dim=None,\n use_checkpoint=True, disable_self_attn=False, use_linear=False):\n super().__init__()\n self.in_channels = in_channels\n inner_dim = n_heads * d_head\n self.norm = torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)\n if not use_linear:\n self.proj_in = nn.Conv2d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0)\n else:\n self.proj_in = nn.Linear(in_channels, inner_dim)\n\n self.transformer_blocks = nn.ModuleList([\n BasicTransformerBlock(\n inner_dim,\n n_heads,\n d_head,\n dropout=dropout,\n context_dim=context_dim,\n disable_self_attn=disable_self_attn,\n checkpoint=use_checkpoint) for d in range(depth)\n ])\n if not use_linear:\n self.proj_out = zero_module(nn.Conv2d(inner_dim, in_channels, kernel_size=1, stride=1, padding=0))\n else:\n self.proj_out = zero_module(nn.Linear(inner_dim, in_channels))\n self.use_linear = use_linear\n\n\n def forward(self, x, context=None):\n b, c, h, w = x.shape\n x_in = x\n x = self.norm(x)\n if not self.use_linear:\n x = self.proj_in(x)\n x = rearrange(x, 'b c h w -> b (h w) c').contiguous()\n if self.use_linear:\n x = self.proj_in(x)\n for i, block in enumerate(self.transformer_blocks):\n x = block(x, context=context)\n if self.use_linear:\n x = self.proj_out(x)\n x = rearrange(x, 'b (h w) c -> b c h w', h=h, w=w).contiguous()\n if not self.use_linear:\n x = self.proj_out(x)\n return x + x_in" }, { "identifier": "TemporalTransformer", "path": "lvdm/modules/attention.py", "snippet": "class TemporalTransformer(nn.Module):\n \"\"\"\n Transformer block for image-like data in temporal axis.\n First, reshape to b, t, d.\n Then apply standard transformer action.\n Finally, reshape to image\n \"\"\"\n def __init__(self, in_channels, n_heads, d_head, depth=1, dropout=0., context_dim=None,\n use_checkpoint=True, use_linear=False, only_self_att=True, causal_attention=False,\n relative_position=False, temporal_length=None, use_image_dataset=False):\n super().__init__()\n self.only_self_att = only_self_att\n self.relative_position = relative_position\n self.causal_attention = causal_attention\n self.use_image_dataset = use_image_dataset\n self.in_channels = in_channels\n inner_dim = n_heads * d_head\n self.norm = torch.nn.GroupNorm(num_groups=32, num_channels=in_channels, eps=1e-6, affine=True)\n self.proj_in = nn.Conv1d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0)\n if not use_linear:\n self.proj_in = nn.Conv1d(in_channels, inner_dim, kernel_size=1, stride=1, padding=0)\n else:\n self.proj_in = nn.Linear(in_channels, inner_dim)\n\n if relative_position:\n assert(temporal_length is not None)\n attention_cls = partial(CrossAttention, relative_position=True, temporal_length=temporal_length)\n else:\n attention_cls = None\n\n if self.only_self_att:\n context_dim = None\n self.transformer_blocks = nn.ModuleList([\n BasicTransformerBlock(\n inner_dim,\n n_heads,\n d_head,\n dropout=dropout,\n context_dim=context_dim,\n attention_cls=attention_cls,\n checkpoint=use_checkpoint) for d in range(depth)\n ])\n if not use_linear:\n self.proj_out = zero_module(nn.Conv1d(inner_dim, in_channels, kernel_size=1, stride=1, padding=0))\n else:\n self.proj_out = zero_module(nn.Linear(inner_dim, in_channels))\n self.use_linear = use_linear\n\n def forward(self, x, context=None, is_imgbatch=False):\n b, c, t, h, w = x.shape\n x_in = x\n x = self.norm(x)\n x = rearrange(x, 'b c t h w -> (b h w) c t').contiguous()\n if not self.use_linear:\n x = self.proj_in(x)\n x = rearrange(x, 'bhw c t -> bhw t c').contiguous()\n if self.use_linear:\n x = self.proj_in(x)\n\n temp_mask = None\n if self.causal_attention:\n temp_mask = torch.tril(torch.ones([1, t, t]))\n if is_imgbatch:\n temp_mask = torch.eye(t).unsqueeze(0)\n if temp_mask is not None:\n mask = temp_mask.to(x.device)\n mask = repeat(mask, 'l i j -> (l bhw) i j', bhw=b*h*w)\n else:\n mask = None\n\n if self.only_self_att:\n ## note: if no context is given, cross-attention defaults to self-attention\n for i, block in enumerate(self.transformer_blocks):\n x = block(x, mask=mask)\n x = rearrange(x, '(b hw) t c -> b hw t c', b=b).contiguous()\n else:\n x = rearrange(x, '(b hw) t c -> b hw t c', b=b).contiguous()\n context = rearrange(context, '(b t) l con -> b t l con', t=t).contiguous()\n for i, block in enumerate(self.transformer_blocks):\n # calculate each batch one by one (since number in shape could not greater then 65,535 for some package)\n for j in range(b):\n unit_context = context[j][0:1]\n context_j = repeat(unit_context, 't l con -> (t r) l con', r=(h * w)).contiguous()\n ## note: causal mask will not applied in cross-attention case\n x[j] = block(x[j], context=context_j)\n \n if self.use_linear:\n x = self.proj_out(x)\n x = rearrange(x, 'b (h w) t c -> b c t h w', h=h, w=w).contiguous()\n if not self.use_linear:\n x = rearrange(x, 'b hw t c -> (b hw) c t').contiguous()\n x = self.proj_out(x)\n x = rearrange(x, '(b h w) c t -> b c t h w', b=b, h=h, w=w).contiguous()\n\n if self.use_image_dataset:\n x = 0.0 * x + x_in\n else:\n x = x + x_in\n return x" } ]

[ { "identifier": "TicTacToe2DNetwork", "path": "models.py", "snippet": "class TicTacToe2DNetwork(nn.Module):\n def __init__(self, input_shape, action_space, first_linear_size=512, second_linear_size=256):\n super().__init__()\n self.conv1 = nn.Conv2d(1, 32, kernel_size=1)\n self.conv2 = nn.Conv2d(32, 32, kernel_size=1)\n self.conv3 = nn.Conv2d(32, 64, kernel_size=1)\n self.dropout = nn.Dropout2d(p=0.3)\n self.fc1 = nn.Linear(3 * 3 * 64, first_linear_size)\n self.fc2 = nn.Linear(first_linear_size, second_linear_size)\n self.value_head = nn.Linear(second_linear_size, 1)\n self.policy_head = nn.Linear(second_linear_size, action_space)\n\n self.device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n self.to(self.device)\n\n def __call__(self, observations):\n self.train()\n x = F.relu(self.conv1(observations))\n x = F.relu(self.conv2(x))\n x = F.relu(self.conv3(x))\n x = self.dropout(x)\n x = x.view(-1, 3 * 3 * 64)\n x = F.relu(self.fc1(x))\n x = F.relu(self.fc2(x))\n value = F.tanh(self.value_head(x))\n log_policy = F.log_softmax(self.policy_head(x), dim=-1)\n return value, log_policy\n\n def value_forward(self, observation):\n self.eval()\n with torch.no_grad():\n x = F.relu(self.conv1(observation))\n x = F.relu(self.conv2(x))\n x = F.relu(self.conv3(x))\n x = x.view(-1, 3 * 3 * 64)\n x = F.relu(self.fc1(x))\n x = F.relu(self.fc2(x))\n value = F.tanh(self.value_head(x))\n return value[0]\n\n def policy_forward(self, observation):\n self.eval()\n with torch.no_grad():\n x = F.relu(self.conv1(observation))\n x = F.relu(self.conv2(x))\n x = F.relu(self.conv3(x))\n x = x.view(-1, 3 * 3 * 64)\n x = F.relu(self.fc1(x))\n x = F.relu(self.fc2(x))\n log_policy = F.softmax(self.policy_head(x), dim=-1)\n return log_policy[0]" }, { "identifier": "AlphaZeroAgentTrainer", "path": "agents.py", "snippet": "class AlphaZeroAgentTrainer(AlphaZeroAgent):\n def __init__(self, model, optimizer, replay_buffer_max_size):\n super().__init__(model)\n self.optimizer = optimizer\n self.replay_buffer = ReplayBuffer(max_size=replay_buffer_max_size)\n\n def _selfplay(self, game, search_iterations, c_puct=1.0, dirichlet_alpha=None):\n buffer = []\n while (first_person_result := game.get_first_person_result()) is None:\n root_node = search(\n game, self.value_fn, self.policy_fn, search_iterations, c_puct=c_puct, dirichlet_alpha=dirichlet_alpha\n )\n visits_dist = root_node.children_visits / root_node.children_visits.sum()\n\n action = root_node.children_actions[np.random.choice(len(root_node.children), p=visits_dist)]\n\n actions_dist = np.zeros(game.action_space, dtype=np.float32)\n actions_dist[root_node.children_actions] = visits_dist\n buffer.append((game.to_observation(), actions_dist))\n\n game.step(action)\n\n return first_person_result, buffer\n\n def train_step(self, game, search_iterations, batch_size, epochs, c_puct=1.0, dirichlet_alpha=None):\n first_person_result, game_buffer = self._selfplay(\n game, search_iterations, c_puct=c_puct, dirichlet_alpha=dirichlet_alpha\n )\n\n result = game.swap_result(first_person_result)\n while len(game_buffer) > 0:\n observation, action_dist = game_buffer.pop()\n self.replay_buffer.add_sample(observation, action_dist, result)\n result = game.swap_result(result)\n\n values_losses, policies_losses = [], []\n if len(self.replay_buffer) >= batch_size:\n for _ in range(epochs):\n observations, actions_dist, results = self.replay_buffer.sample(batch_size)\n observations = torch.tensor(observations, device=self.model.device)\n actions_dist = torch.tensor(actions_dist, device=self.model.device)\n results = torch.tensor(results, device=self.model.device)\n\n self.optimizer.zero_grad()\n values, log_policies = self.model(observations)\n\n # mean squared error\n values_loss = F.mse_loss(values.squeeze(1), results)\n # Kullback–Leibler divergence\n policies_loss = F.kl_div(log_policies, actions_dist, reduction=\"batchmean\")\n\n (values_loss + policies_loss).backward()\n self.optimizer.step()\n\n values_losses.append(values_loss.item())\n policies_losses.append(policies_loss.item())\n\n return values_losses, policies_losses\n\n def save_training_state(self, model_out_path, optimizer_out_path):\n torch.save(self.model.state_dict(), model_out_path)\n torch.save(self.optimizer.state_dict(), optimizer_out_path)\n\n def load_training_state(self, model_out_path, optimizer_out_path):\n self.model.load_state_dict(torch.load(model_out_path))\n self.optimizer.load_state_dict(torch.load(optimizer_out_path))" } ]

[ { "identifier": "Language", "path": "CybersecurityBenchmarks/insecure_code_detector/languages.py", "snippet": "class Language(str, enum.Enum):\n C = \"c\"\n CPP = \"cpp\"\n CSHARP = \"csharp\"\n HACK = \"hack\"\n JAVA = \"java\"\n JAVASCRIPT = \"javascript\"\n KOTLIN = \"kotlin\"\n OBJECTIVE_C = \"objective_c\"\n OBJECTIVE_CPP = \"objective_cpp\"\n PHP = \"php\"\n PYTHON = \"python\"\n RUBY = \"ruby\"\n RUST = \"rust\"\n SWIFT = \"swift\"\n XML = \"xml\"\n\n def __str__(self) -> str:\n return self.name.lower()" }, { "identifier": "InsecureCodeDetectorTest", "path": "CybersecurityBenchmarks/insecure_code_detector/tests/insecure_code_detector_test.py", "snippet": "class InsecureCodeDetectorTest(unittest.IsolatedAsyncioTestCase, ABC):\n @unittest.skipUnless(oss.ENABLE_REGEX_ANALYZER, \"Regex analyzer not enabled\")\n async def run_regex_tests(\n self, language: Language, tests: list[tuple[str, int]]\n ) -> None:\n for test_case in tests:\n test_input, expected_count = test_case\n result = await insecure_code_detector.analyze(language, test_input)\n print(test_case)\n print(result)\n self.assertEqual(len(result), expected_count)\n\n @unittest.skipUnless(oss.ENABLE_WEGGLI, \"Weggli analyzer not enabled\")\n async def run_weggli_tests(\n self, language: Language, tests: list[tuple[str, int]]\n ) -> None:\n for test_case in tests:\n test_input, expected_count = test_case\n result = await insecure_code_detector.analyze(\n language, test_input, \"void foo(){\\n\", \"\\n}\"\n )\n self.assertEqual(\n len(result), expected_count, \"Test failed: {}\".format(test_input)\n )\n\n @unittest.skipUnless(oss.ENABLE_SEMGREP, \"Semgrep analyzer not enabled\")\n async def run_semgrep_tests(\n self, language: Language, tests: list[tuple[str, int]]\n ) -> None:\n for test_case in tests:\n test_input, expected_count = test_case\n result = await insecure_code_detector.analyze(language, test_input)\n self.assertEqual(\n len(result), expected_count, \"Test failed: {}\".format(test_input)\n )" } ]

[ { "identifier": "get_video_length", "path": "create_data/utils.py", "snippet": "def get_video_length(video_path):\n \"\"\"this gets just the video stream length (in the case audio stream is longer)\"\"\"\n # E.g. k700-2020/train/watering plants/af3epdZsrTc_000178_000188.mp4\n # if audio is shorter than video stream, just pad that\n # \"-select_streams v:0\" gets the video stream, '-select_streams a:0\" is audio stream\n proc = subprocess.Popen(['ffprobe', '-v', 'error', '-select_streams', 'v:0', '-show_entries', 'stream=duration',\n '-of', 'default=noprint_wrappers=1:nokey=1', video_path],\n stdout=subprocess.PIPE, stderr=subprocess.STDOUT)\n\n out, _ = proc.communicate()\n duration = out.decode('utf-8')\n\n try:\n duration = float(out.strip())\n except ValueError:\n logging.warning(f\"Invalid duration for {video_path}: {duration}\")\n duration = None\n\n return duration" }, { "identifier": "create_audio_from_video", "path": "create_data/utils.py", "snippet": "def create_audio_from_video(video_file:str, audio_dir: None, audio_file_timeout=-1, sampling_rate:int=16000, force:bool=False):\n \"\"\"Create .wav file from video\"\"\"\n\n if audio_dir is not None:\n audio_file = path.join(audio_dir, Path(video_file).stem + \".wav\")\n else:\n audio_file = path.splitext(video_file)[0] + \".wav\"\n\n if not path.isfile(audio_file) or force:\n ffmpeg_process = subprocess.Popen(\n ['ffmpeg', '-y', '-i', str(video_file), '-ac', '1', '-ar', str(sampling_rate), audio_file],\n stdout=-1, stderr=-1, text=True)\n\n if audio_file_timeout == -1:\n # wait however long it takes to create the audio file\n ffmpeg_process.wait()\n else:\n try:\n ffmpeg_process.communicate(None, timeout=audio_file_timeout)\n except subprocess.TimeoutExpired:\n # if the audio file hasn't been created yet, abandon hope\n logging.warning(f\"Couldn't create .wav from {video_file} in timeout of {audio_file_timeout}.\")\n ffmpeg_process.kill()\n return None\n ffmpeg_process.kill()\n\n return audio_file" }, { "identifier": "extract_frames_from_video", "path": "create_data/utils.py", "snippet": "def extract_frames_from_video(video_path,\n video_length,\n video_segment_length,\n times=None,\n clip_start_time=0,\n clip_end_time=None,\n num_frames=None,\n resize=True,\n target_size=512,\n multiprocess=False):\n \"\"\"\n Control frame times:\n - automatically compute from below (default) OR\n - manually set\n\n Control number of frames or sampling duration:\n - specify number of frames (num_frames) OR\n - specify duration between segments (video_segment_length)\n\n Control where to sample from:\n - between [0,video_length] (default) OR\n - between [clip_start_time,clip_end_time]\n\n video_length may be provided. If set to None, video_length will be computed\n from video_path.\n \"\"\"\n if times is None:\n # automatically calculate what times to extract frames for\n if video_length is None:\n video_length = get_video_length(video_path)\n\n if clip_end_time is not None:\n clip_duration = clip_end_time - clip_start_time\n if clip_duration <= video_length:\n video_length = clip_duration\n\n # one and only one of video_segment_length and num_frames should be None\n assert video_segment_length is not None or num_frames is not None\n assert video_segment_length is None or num_frames is None\n\n if num_frames is None:\n # allows extra frame only if for >=50% of the segment video is available\n num_segments = get_num_segments(video_length, video_segment_length)\n else:\n num_segments = num_frames\n\n # frames are located at the midpoint of a segment\n boundaries = np.linspace(clip_start_time, clip_end_time, num_segments + 1).tolist()\n extract_times = [(boundaries[i] + boundaries[i+1]) / 2.0 for i in range(num_segments)]\n else:\n extract_times = times\n boundaries = None\n\n # extract the frames\n if multiprocess:\n pool = multiprocessing.Pool()\n frames = pool.starmap(extract_single_frame_from_video,\n zip(itertools.repeat(video_path), extract_times))\n else:\n # TODO Can we get all frames with one video read\n frames = [extract_single_frame_from_video(video_path, time) for time in extract_times]\n\n # check to see if any extraction failed\n if any([x is None for x in frames]) or frames is None or len(frames) == 0:\n logging.warning(f\"Failed to extract frames from {video_path}\")\n return None, None\n\n # resize the frames to have shorter side of size 512\n if resize:\n if isinstance(target_size, int):\n frames = [resize_image_by_shorter_side(im, target_size=target_size) for im in frames]\n else:\n assert len(target_size) == 2, target_size # type: ignore\n frames = [\n skimage.transform.resize(\n im, target_size, anti_aliasing=True, preserve_range=True\n )\n for im in frames\n ]\n\n return np.stack(frames).astype(np.uint8), boundaries" }, { "identifier": "BUFFER_FROM_END", "path": "create_data/utils.py", "snippet": "BUFFER_FROM_END = 0.1" }, { "identifier": "extract_spectrograms_from_audio", "path": "demo/utils/audio_utils.py", "snippet": "def extract_spectrograms_from_audio(\n audio_file: Union[str, np.ndarray],\n audio_segment_length: float = AUDIO_SEGMENT_LENGTH,\n spectrogram_length: float = AUDIO_SPECTRUM_LENGTH,\n audio_length=None,\n sampling_rate: int = AUDIO_SAMPLING_RATE,\n):\n # read in the audio file\n if isinstance(audio_file, str):\n waveform = read_audio_file(audio_file)\n else:\n assert audio_file.ndim == 1\n # cached waveform\n waveform = audio_file\n if waveform is None:\n print(\"NO AUDIO FROM WAVEFILE!\")\n return None\n\n if audio_length is None:\n # get actual audio length\n audio_length = get_audio_length(audio_file)\n if audio_length is None:\n print(f\"Couldn't get audio length for {audio_file}\")\n return None\n\n num_segments = get_num_segments(audio_length, audio_segment_length)\n boundaries = np.linspace(\n 0, num_segments * audio_segment_length, num_segments + 1\n ).tolist()\n\n # Pad to max time just in case, crop if longer\n max_samples = int(sampling_rate * num_segments * audio_segment_length)\n if waveform.size < max_samples:\n waveform = np.concatenate(\n [waveform, np.zeros(max_samples - waveform.size, dtype=np.float32)], 0\n )\n waveform = waveform[:max_samples]\n\n # split waveform into segments\n spectrograms = []\n for i in range(num_segments):\n if audio_segment_length <= spectrogram_length:\n ts_start = int(boundaries[i] * sampling_rate)\n ts_end = int(boundaries[i + 1] * sampling_rate)\n waveform_segment = waveform[ts_start:ts_end]\n num_pad = int(sampling_rate * spectrogram_length) - (ts_end - ts_start)\n if num_pad > 0:\n waveform_segment = np.concatenate(\n [\n np.zeros(num_pad // 2, dtype=np.float32),\n waveform_segment,\n np.zeros(num_pad - num_pad // 2, dtype=np.float32),\n ],\n 0,\n )\n waveform_segment = waveform_segment[\n : int(sampling_rate * spectrogram_length)\n ]\n else:\n ts_start = int(boundaries[i] * sampling_rate)\n ts_end = int(boundaries[i + 1] * sampling_rate)\n ts_mid = (ts_start + ts_end) / 2\n start = int(ts_mid - sampling_rate * spectrogram_length / 2)\n end = start + int(sampling_rate * spectrogram_length)\n waveform_segment = waveform[start:end]\n # Create spectrogram from waveform\n try:\n spectrogram = make_spectrogram(\n waveform_segment, sampling_rate, n_fft=1024, hop_length=256\n ) # shape (128, 256)\n except Exception as exc:\n print(f\"Couldn't make spectrogram, {exc}\")\n return None\n spectrograms.append(spectrogram)\n\n if len(spectrograms) == 0:\n assert num_segments == 0\n print(\"Couldn't make spectrograms: num_segments is 0\")\n return None\n\n # (N,128,256) is (# of segments, # of mel bands in spectrogram, # of hops in spectrogram)\n spectrograms = np.stack(spectrograms).astype(np.float32)\n assert spectrograms.shape[1:] == (128, 256)\n\n # if spectrograms.shape[1:] != (128, 256):\n # print(\n # f\"Non-standard spectrogram shape produced! Should be (N,128,256) but is {spectrograms.shape}\"\n # )\n # return None\n\n return spectrograms" } ]

[ { "identifier": "parallel_execution", "path": "easyvolcap/utils/parallel_utils.py", "snippet": "def parallel_execution(*args, action: Callable, num_workers=32, print_progress=False, sequential=False, async_return=False, desc=None, use_process=False, **kwargs):\n \"\"\"\n Executes a given function in parallel using threads or processes.\n When using threads, the parallelism is achieved during IO blocking (i.e. when loading images from disk or writing something to disk).\n If your task is compute intensive, consider using packages like numpy or torch since they release the GIL during heavy lifting.\n\n Args:\n *args: Variable length argument list.\n action (Callable): The function to execute in parallel.\n num_workers (int): The number of worker threads or processes to use.\n print_progress (bool): Whether to print a progress bar.\n sequential (bool): Whether to execute the function sequentially instead of in parallel.\n async_return (bool): Whether to return a pool object for asynchronous results.\n desc (str): The description to use for the progress bar.\n use_process (bool): Whether to use processes instead of threads.\n **kwargs: Arbitrary keyword arguments.\n\n Returns:\n If `async_return` is False, returns a list of the results of executing the function on each input argument.\n If `async_return` is True, returns a pool object for asynchronous results.\n \"\"\"\n\n # https://superfastpython.com/threadpool-python/\n # Python threads are well suited for use with IO-bound tasks\n # MARK: DO NOT USE THIS FOR CPU BOUND TASK. THIS IS A CHEAP \"THREAD\" POOL WHICH SUCCUMBS TO PYTHON GIL\n # MARK: USE POOL INTEAD OF THREAD POOL IF THAT IS THE CASE\n # NOTE: we expect first arg / or kwargs to be distributed\n # NOTE: print_progress arg is reserved\n\n def get_length(args: List, kwargs: Dict):\n for a in args:\n if isinstance(a, list):\n return len(a)\n for v in kwargs.values():\n if isinstance(v, list):\n return len(v)\n raise NotImplementedError\n\n def get_action_args(length: int, args: List, kwargs: Dict, i: int):\n action_args = [(arg[i] if isinstance(arg, list) and len(arg) == length else arg) for arg in args]\n # TODO: Support all types of iterable\n action_kwargs = {key: (kwargs[key][i] if isinstance(kwargs[key], list) and len(kwargs[key]) == length else kwargs[key]) for key in kwargs}\n return action_args, action_kwargs\n\n if not sequential:\n # Create ThreadPool\n if use_process:\n pool = Pool(processes=num_workers)\n else:\n pool = ThreadPool(processes=num_workers)\n\n # Spawn threads\n results = []\n asyncs = []\n length = get_length(args, kwargs)\n for i in range(length):\n action_args, action_kwargs = get_action_args(length, args, kwargs, i)\n async_result = pool.apply_async(action, action_args, action_kwargs)\n asyncs.append(async_result)\n\n # Join threads and get return values\n if not async_return:\n for async_result in tqdm(asyncs, back=3, desc=desc, disable=not print_progress): # log previous frame\n results.append(async_result.get()) # will sync the corresponding thread\n pool.close()\n pool.join()\n return results\n else:\n return pool\n else:\n results = []\n length = get_length(args, kwargs)\n for i in tqdm(range(length), back=3, desc=desc, disable=not print_progress): # log previous frame\n action_args, action_kwargs = get_action_args(length, args, kwargs, i)\n async_result = action(*action_args, **action_kwargs)\n results.append(async_result)\n return results" }, { "identifier": "run", "path": "easyvolcap/utils/console_utils.py", "snippet": "def run(cmd,\n quite=False,\n dry_run=False,\n skip_failed=False,\n invokation=os.system, # or subprocess.run\n ):\n \"\"\"\n Run a shell command and print the command to the console.\n\n Args:\n cmd (str or list): The command to run. If a list, it will be joined with spaces.\n quite (bool): If True, suppress console output.\n dry_run (bool): If True, print the command but do not execute it.\n\n Raises:\n RuntimeError: If the command returns a non-zero exit code.\n\n Returns:\n None\n \"\"\"\n if isinstance(cmd, list):\n cmd = ' '.join(list(map(str, cmd)))\n func = sys._getframe(1).f_code.co_name\n if not quite:\n cmd_color = 'cyan' if not cmd.startswith('rm') else 'red'\n cmd_color = 'green' if dry_run else cmd_color\n dry_msg = magenta('[dry_run]: ') if dry_run else ''\n log(yellow(func), '->', green(invokation.__name__) + \":\", dry_msg + color(cmd, cmd_color), no_prefix=True)\n # print(color(cmd, cmd_color), soft_wrap=False)\n if not dry_run:\n code = invokation(cmd)\n else:\n code = 0\n if code != 0 and not skip_failed:\n log(red(code), \"<-\", yellow(func) + \":\", red(cmd), no_prefix=True)\n # print(red(cmd), soft_wrap=True)\n raise RuntimeError(f'{code} <- {func}: {cmd}')\n else:\n return code # or output" }, { "identifier": "log", "path": "easyvolcap/utils/console_utils.py", "snippet": "def log(*stuff,\n back=1,\n file: Optional[IO[str]] = None,\n no_prefix=False,\n module_color=blue,\n func_color=green,\n console: Optional[Console] = console,\n **kwargs):\n \"\"\"\n Perform logging using the built in shared logger\n \"\"\"\n writer = console if file is None else Console(file=file, soft_wrap=True, tab_size=4, log_time_format=verbose_time_format) # shared\n writer._log_render.time_format = verbose_time_format if verbose_log else slim_time_format\n if no_prefix or not verbose_log: writer.log(*stuff, _stack_offset=2, **kwargs)\n else: writer.log(get_log_prefix(back + 1, module_color, func_color), *stuff, _stack_offset=2, **kwargs)" }, { "identifier": "run_if_not_exists", "path": "easyvolcap/utils/console_utils.py", "snippet": "def run_if_not_exists(cmd, outname, *args, **kwargs):\n # whether a file exists, whether a directory has more than 3 elements\n # if (os.path.exists(outname) and os.path.isfile(outname)) or (os.path.isdir(outname) and len(os.listdir(outname)) >= 3):\n if os.path.exists(outname):\n log(yellow('Skipping:'), cyan(cmd))\n else:\n run(cmd, *args, **kwargs)" } ]

[ { "identifier": "read_extrinsics_text", "path": "scene/colmap_loader.py", "snippet": "def read_extrinsics_text(path):\n \"\"\"\n Taken from https://github.com/colmap/colmap/blob/dev/scripts/python/read_write_model.py\n \"\"\"\n images = {}\n with open(path, \"r\") as fid:\n while True:\n line = fid.readline()\n if not line:\n break\n line = line.strip()\n if len(line) > 0 and line[0] != \"#\":\n elems = line.split()\n image_id = int(elems[0])\n qvec = np.array(tuple(map(float, elems[1:5])))\n tvec = np.array(tuple(map(float, elems[5:8])))\n camera_id = int(elems[8])\n image_name = elems[9]\n elems = fid.readline().split()\n xys = np.column_stack([tuple(map(float, elems[0::3])),\n tuple(map(float, elems[1::3]))])\n point3D_ids = np.array(tuple(map(int, elems[2::3])))\n images[image_id] = Image(\n id=image_id, qvec=qvec, tvec=tvec,\n camera_id=camera_id, name=image_name,\n xys=xys, point3D_ids=point3D_ids)\n return images" }, { "identifier": "read_intrinsics_text", "path": "scene/colmap_loader.py", "snippet": "def read_intrinsics_text(path):\n \"\"\"\n Taken from https://github.com/colmap/colmap/blob/dev/scripts/python/read_write_model.py\n \"\"\"\n cameras = {}\n with open(path, \"r\") as fid:\n while True:\n line = fid.readline()\n if not line:\n break\n line = line.strip()\n if len(line) > 0 and line[0] != \"#\":\n elems = line.split()\n camera_id = int(elems[0])\n model = elems[1]\n assert model == \"PINHOLE\", \"While the loader support other types, the rest of the code assumes PINHOLE\"\n width = int(elems[2])\n height = int(elems[3])\n params = np.array(tuple(map(float, elems[4:])))\n cameras[camera_id] = Camera(id=camera_id, model=model,\n width=width, height=height,\n params=params)\n return cameras" }, { "identifier": "qvec2rotmat", "path": "scene/colmap_loader.py", "snippet": "def qvec2rotmat(qvec):\n return np.array([\n [1 - 2 * qvec[2]**2 - 2 * qvec[3]**2,\n 2 * qvec[1] * qvec[2] - 2 * qvec[0] * qvec[3],\n 2 * qvec[3] * qvec[1] + 2 * qvec[0] * qvec[2]],\n [2 * qvec[1] * qvec[2] + 2 * qvec[0] * qvec[3],\n 1 - 2 * qvec[1]**2 - 2 * qvec[3]**2,\n 2 * qvec[2] * qvec[3] - 2 * qvec[0] * qvec[1]],\n [2 * qvec[3] * qvec[1] - 2 * qvec[0] * qvec[2],\n 2 * qvec[2] * qvec[3] + 2 * qvec[0] * qvec[1],\n 1 - 2 * qvec[1]**2 - 2 * qvec[2]**2]])" }, { "identifier": "read_extrinsics_binary", "path": "scene/colmap_loader.py", "snippet": "def read_extrinsics_binary(path_to_model_file):\n \"\"\"\n see: src/base/reconstruction.cc\n void Reconstruction::ReadImagesBinary(const std::string& path)\n void Reconstruction::WriteImagesBinary(const std::string& path)\n \"\"\"\n images = {}\n with open(path_to_model_file, \"rb\") as fid:\n num_reg_images = read_next_bytes(fid, 8, \"Q\")[0]\n for _ in range(num_reg_images):\n binary_image_properties = read_next_bytes(\n fid, num_bytes=64, format_char_sequence=\"idddddddi\")\n image_id = binary_image_properties[0]\n qvec = np.array(binary_image_properties[1:5])\n tvec = np.array(binary_image_properties[5:8])\n camera_id = binary_image_properties[8]\n image_name = \"\"\n current_char = read_next_bytes(fid, 1, \"c\")[0]\n while current_char != b\"\\x00\": # look for the ASCII 0 entry\n image_name += current_char.decode(\"utf-8\")\n current_char = read_next_bytes(fid, 1, \"c\")[0]\n num_points2D = read_next_bytes(fid, num_bytes=8,\n format_char_sequence=\"Q\")[0]\n x_y_id_s = read_next_bytes(fid, num_bytes=24*num_points2D,\n format_char_sequence=\"ddq\"*num_points2D)\n xys = np.column_stack([tuple(map(float, x_y_id_s[0::3])),\n tuple(map(float, x_y_id_s[1::3]))])\n point3D_ids = np.array(tuple(map(int, x_y_id_s[2::3])))\n images[image_id] = Image(\n id=image_id, qvec=qvec, tvec=tvec,\n camera_id=camera_id, name=image_name,\n xys=xys, point3D_ids=point3D_ids)\n return images" }, { "identifier": "read_intrinsics_binary", "path": "scene/colmap_loader.py", "snippet": "def read_intrinsics_binary(path_to_model_file):\n \"\"\"\n see: src/base/reconstruction.cc\n void Reconstruction::WriteCamerasBinary(const std::string& path)\n void Reconstruction::ReadCamerasBinary(const std::string& path)\n \"\"\"\n cameras = {}\n with open(path_to_model_file, \"rb\") as fid:\n num_cameras = read_next_bytes(fid, 8, \"Q\")[0]\n for _ in range(num_cameras):\n camera_properties = read_next_bytes(\n fid, num_bytes=24, format_char_sequence=\"iiQQ\")\n camera_id = camera_properties[0]\n model_id = camera_properties[1]\n model_name = CAMERA_MODEL_IDS[camera_properties[1]].model_name\n width = camera_properties[2]\n height = camera_properties[3]\n num_params = CAMERA_MODEL_IDS[model_id].num_params\n params = read_next_bytes(fid, num_bytes=8*num_params,\n format_char_sequence=\"d\"*num_params)\n cameras[camera_id] = Camera(id=camera_id,\n model=model_name,\n width=width,\n height=height,\n params=np.array(params))\n assert len(cameras) == num_cameras\n return cameras" }, { "identifier": "read_points3D_binary", "path": "scene/colmap_loader.py", "snippet": "def read_points3D_binary(path_to_model_file):\n \"\"\"\n see: src/base/reconstruction.cc\n void Reconstruction::ReadPoints3DBinary(const std::string& path)\n void Reconstruction::WritePoints3DBinary(const std::string& path)\n \"\"\"\n\n\n with open(path_to_model_file, \"rb\") as fid:\n num_points = read_next_bytes(fid, 8, \"Q\")[0]\n\n xyzs = np.empty((num_points, 3))\n rgbs = np.empty((num_points, 3))\n errors = np.empty((num_points, 1))\n\n for p_id in range(num_points):\n binary_point_line_properties = read_next_bytes(\n fid, num_bytes=43, format_char_sequence=\"QdddBBBd\")\n xyz = np.array(binary_point_line_properties[1:4])\n rgb = np.array(binary_point_line_properties[4:7])\n error = np.array(binary_point_line_properties[7])\n track_length = read_next_bytes(\n fid, num_bytes=8, format_char_sequence=\"Q\")[0]\n track_elems = read_next_bytes(\n fid, num_bytes=8*track_length,\n format_char_sequence=\"ii\"*track_length)\n xyzs[p_id] = xyz\n rgbs[p_id] = rgb\n errors[p_id] = error\n return xyzs, rgbs, errors" }, { "identifier": "read_points3D_text", "path": "scene/colmap_loader.py", "snippet": "def read_points3D_text(path):\n \"\"\"\n see: src/base/reconstruction.cc\n void Reconstruction::ReadPoints3DText(const std::string& path)\n void Reconstruction::WritePoints3DText(const std::string& path)\n \"\"\"\n xyzs = None\n rgbs = None\n errors = None\n num_points = 0\n with open(path, \"r\") as fid:\n while True:\n line = fid.readline()\n if not line:\n break\n line = line.strip()\n if len(line) > 0 and line[0] != \"#\":\n num_points += 1\n\n\n xyzs = np.empty((num_points, 3))\n rgbs = np.empty((num_points, 3))\n errors = np.empty((num_points, 1))\n count = 0\n with open(path, \"r\") as fid:\n while True:\n line = fid.readline()\n if not line:\n break\n line = line.strip()\n if len(line) > 0 and line[0] != \"#\":\n elems = line.split()\n xyz = np.array(tuple(map(float, elems[1:4])))\n rgb = np.array(tuple(map(int, elems[4:7])))\n error = np.array(float(elems[7]))\n xyzs[count] = xyz\n rgbs[count] = rgb\n errors[count] = error\n count += 1\n\n return xyzs, rgbs, errors" }, { "identifier": "getWorld2View2", "path": "utils/graphics_utils.py", "snippet": "def getWorld2View2(R, t, translate=np.array([.0, .0, .0]), scale=1.0):\n Rt = np.zeros((4, 4))\n Rt[:3, :3] = R.transpose()\n Rt[:3, 3] = t\n Rt[3, 3] = 1.0\n\n C2W = np.linalg.inv(Rt)\n cam_center = C2W[:3, 3]\n cam_center = (cam_center + translate) * scale\n C2W[:3, 3] = cam_center\n Rt = np.linalg.inv(C2W)\n return np.float32(Rt)" }, { "identifier": "focal2fov", "path": "utils/graphics_utils.py", "snippet": "def focal2fov(focal, pixels):\n return 2*math.atan(pixels/(2*focal))" }, { "identifier": "fov2focal", "path": "utils/graphics_utils.py", "snippet": "def fov2focal(fov, pixels):\n return pixels / (2 * math.tan(fov / 2))" }, { "identifier": "SH2RGB", "path": "utils/sh_utils.py", "snippet": "def SH2RGB(sh):\n return sh * C0 + 0.5" }, { "identifier": "BasicPointCloud", "path": "scene/gaussian_model.py", "snippet": "class GaussianModel:\n def setup_functions(self):\n def build_covariance_from_scaling_rotation(scaling, scaling_modifier, rotation):\n def __init__(self, sh_degree : int):\n def capture(self, include_feature=False):\n def restore(self, model_args, training_args, mode='train'):\n def get_scaling(self):\n def get_rotation(self):\n def get_xyz(self):\n def get_features(self):\n def get_opacity(self):\n def get_language_feature(self):\n def get_covariance(self, scaling_modifier = 1):\n def oneupSHdegree(self):\n def create_from_pcd(self, pcd : BasicPointCloud, spatial_lr_scale : float):\n def training_setup(self, training_args):\n def update_learning_rate(self, iteration):\n def construct_list_of_attributes(self):\n def save_ply(self, path):\n def reset_opacity(self):\n def load_ply(self, path):\n def replace_tensor_to_optimizer(self, tensor, name):\n def _prune_optimizer(self, mask):\n def prune_points(self, mask):\n def cat_tensors_to_optimizer(self, tensors_dict):\n def densification_postfix(self, new_xyz, new_features_dc, new_features_rest, new_opacities, new_scaling, new_rotation):\n def densify_and_split(self, grads, grad_threshold, scene_extent, N=2):\n def densify_and_clone(self, grads, grad_threshold, scene_extent):\n def densify_and_prune(self, max_grad, min_opacity, extent, max_screen_size):\n def add_densification_stats(self, viewspace_point_tensor, update_filter):\n L = build_scaling_rotation(scaling_modifier * scaling, rotation)" } ]

[ { "identifier": "sensible_buckets", "path": "utils/bucketing.py", "snippet": "def sensible_buckets(m_width, m_height, w, h, min_size=192):\n if h > w:\n w = resolve_bucket(m_width, h, w)\n w = closest_bucket(m_width, w, 'down', min_size=min_size)\n return w, m_height\n if h < w:\n h = resolve_bucket(m_height, w, h)\n h = closest_bucket(m_height, h, 'down', min_size=min_size)\n return m_width, h\n\n return m_width, m_height" }, { "identifier": "get_moved_area_mask", "path": "utils/common.py", "snippet": "def get_moved_area_mask(frames, move_th=5, th=-1):\n ref_frame = frames[0] \n # Convert the reference frame to gray\n ref_gray = cv2.cvtColor(ref_frame, cv2.COLOR_BGR2GRAY)\n prev_gray = ref_gray\n # Initialize the total accumulated motion mask\n total_mask = np.zeros_like(ref_gray)\n\n # Iterate through the video frames\n for i in range(1, len(frames)):\n frame = frames[i]\n # Convert the frame to gray\n gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)\n\n # Compute the absolute difference between the reference frame and the current frame\n diff = cv2.absdiff(ref_gray, gray)\n #diff += cv2.absdiff(prev_gray, gray)\n\n # Apply a threshold to obtain a binary image\n ret, mask = cv2.threshold(diff, move_th, 255, cv2.THRESH_BINARY)\n\n # Accumulate the mask\n total_mask = cv2.bitwise_or(total_mask, mask)\n\n # Update the reference frame\n prev_gray = gray\n\n contours, _ = cv2.findContours(total_mask, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n rects = []\n ref_mask = np.zeros_like(ref_gray)\n ref_mask = cv2.drawContours(ref_mask, contours, -1, (255, 255, 255), -1)\n for cnt in contours:\n cur_rec = cv2.boundingRect(cnt)\n rects.append(cur_rec) \n\n #rects = merge_overlapping_rectangles(rects)\n mask = np.zeros_like(ref_gray)\n if th < 0:\n h, w = mask.shape\n th = int(h*w*0.005)\n for rect in rects:\n x, y, w, h = rect\n if w*h < th:\n continue\n #ref_frame = cv2.rectangle(ref_frame, (x, y), (x+w, y+h), (0, 255, 0), 2)\n mask[y:y+h, x:x+w] = 255\n return mask" }, { "identifier": "calculate_motion_score", "path": "utils/common.py", "snippet": "def calculate_motion_score(frame_imgs, calculate_edges=False, color=\"RGB\") -> float:\n # Convert image into HSV colorspace.\n _last_frame = None\n\n _weights = [1.0, 1.0, 1.0, 0.0]\n score = 0\n for frame_img in frame_imgs:\n if color == \"RGB\":\n hue, sat, lum = cv2.split(cv2.cvtColor(frame_img, cv2.COLOR_RGB2HSV))\n else:\n hue, sat, lum = cv2.split(cv2.cvtColor(frame_img, cv2.COLOR_BGR2HSV))\n # Performance: Only calculate edges if we have to.\n edges = _detect_edges(lum) if calculate_edges else None\n if _last_frame == None:\n _last_frame = (hue, sat, lum, edges)\n continue\n\n score_components = [\n _mean_pixel_distance(hue, _last_frame[0]),\n _mean_pixel_distance(sat, _last_frame[1]),\n _mean_pixel_distance(lum, _last_frame[2]),\n 0.0 if edges is None else _mean_pixel_distance(edges, _last_frame[3]),\n ]\n\n frame_score: float = (\n sum(component * weight for (component, weight) in zip(score_components, _weights))\n / sum(abs(weight) for weight in _weights))\n score += frame_score\n _last_frame = (hue, sat, lum, edges)\n\n return round(score/(len(frame_imgs)-1) * 10)" } ]

[ { "identifier": "load_config", "path": "agent_search/core/utils.py", "snippet": "def load_config(config_dir: Optional[str] = None) -> configparser.ConfigParser:\n \"\"\"Load the configuration file.\"\"\"\n config = configparser.ConfigParser()\n if not config_dir:\n config_dir = get_data_path()\n config.read(os.path.join(config_dir, \"config.ini\"))\n return config" }, { "identifier": "select_top_urls", "path": "agent_search/core/utils.py", "snippet": "def select_top_urls(\n ordered_points: List[AgentSearchResult],\n max_urls: int = 10,\n url_contains: Optional[List[str]] = None,\n) -> List[str]:\n \"\"\"A function to return the top unique URLs from the given poitns results.\"\"\"\n if not url_contains:\n url_contains = []\n\n top_urls = set([])\n for point in ordered_points:\n url = point.url\n if url in top_urls:\n continue\n url_contains_match = False if url_contains else True\n for url_contain in url_contains:\n if url_contain in url:\n url_contains_match = True\n break\n if not url_contains_match:\n continue\n top_urls.add(point.url)\n if len(top_urls) >= max_urls:\n break\n\n return list(top_urls)" }, { "identifier": "WebSearchEngine", "path": "agent_search/search/base.py", "snippet": "class WebSearchEngine:\n \"\"\"A simple search client for the OpenSearch collection\"\"\"\n\n def __init__(\n self,\n ):\n try:\n import psycopg2\n except ImportError as e:\n raise ImportError(\n f\"Error {e} while imoprting psycopg2. Please install it with `pip install psycopg2` to run an WebSearchEngine instance.\"\n )\n\n # Load config\n self.config = load_config()[\"agent_search\"]\n\n # Load Postgres\n logger.info(\n f\"Connecting to Postgres database at: {self.config['postgres_db']}.\"\n )\n\n # Load qdrant client\n logger.info(\n f\"Connecting to collection: {self.config['qdrant_collection_name']}\"\n )\n self.qdrant_collection_name = self.config[\"qdrant_collection_name\"]\n self.client = QdrantClient(\n self.config[\"qdrant_host\"],\n grpc_port=self.config[\"qdrant_grpc_port\"],\n prefer_grpc=True,\n )\n if not self.client.get_collection(self.qdrant_collection_name):\n raise ValueError(\n f\"Must have a Qdrant collection with the name {self.qdrant_collection_name}.\"\n )\n\n # Load embedding model\n self.embedding_model = AutoModel.from_pretrained(\n self.config[\"embedding_model_name\"], trust_remote_code=True\n )\n\n self.pagerank_rerank_module = self.config[\"pagerank_rerank_module\"]\n pagerank_file_path = self.config[\"pagerank_file_path\"]\n if self.pagerank_rerank_module:\n if not pagerank_file_path:\n # Simulating reading from a CSV file\n pagerank_file_path = os.path.join(\n get_data_path(), \"domain_ranks.csv\"\n )\n\n if not os.path.exists(pagerank_file_path):\n raise ValueError(\n \"Must have a pagerank file at the config specified path when using pagerank_rerank_module\"\n )\n\n self.pagerank_importance = float(\n self.config[\"pagerank_importance\"]\n )\n self.domain_to_rank_map = {}\n\n with open(pagerank_file_path, newline=\"\") as csvfile:\n reader = csv.DictReader(csvfile)\n for row in reader:\n domain = row[\"Domain\"]\n rank = float(row[\"Open Page Rank\"])\n self.domain_to_rank_map[domain] = rank\n\n def get_query_vector(self, query: str):\n \"\"\"Gets the query vector for the given query\"\"\"\n\n query_vector = self.embedding_model.encode(query)\n return query_vector\n\n def similarity_search(\n self,\n query_vector: np.ndarray,\n limit: int = 100,\n ):\n \"\"\"Searches the collection for the given query and returns the top 'limit' results\"\"\"\n\n points = self.client.search(\n collection_name=self.qdrant_collection_name,\n query_vector=query_vector,\n limit=limit,\n )\n\n results = []\n for point in points:\n try:\n results.append(\n AgentSearchResult(\n score=point.score,\n text=point.payload[\"text\"],\n title=None,\n url=point.payload[\"url\"],\n metadata={},\n )\n )\n except Exception as e:\n logger.error(f\"Error appending point {point} with {e}\")\n return results\n\n # Example of batch processing\n def execute_batch_query(self, urls, batch_size=20):\n results = []\n try:\n with psycopg2.connect(\n dbname=self.config[\"postgres_db\"],\n user=self.config[\"postgres_user\"],\n password=self.config[\"postgres_password\"],\n host=self.config[\"postgres_host\"],\n options=\"-c client_encoding=UTF8\",\n ) as conn:\n with conn.cursor() as cur:\n for i in range(0, len(urls), batch_size):\n batch_urls = urls[i : i + batch_size]\n logger.info(\n f\"Executing batch query for URLs: {batch_urls[0:2]}\"\n )\n query = f\"SELECT url, title, metadata, dataset, text_chunks, embeddings FROM {self.config['postgres_table_name']} WHERE url = ANY(%s)\"\n cur.execute(query, (batch_urls,))\n batch_results = cur.fetchall()\n results.extend(batch_results)\n except psycopg2.DatabaseError as e:\n logger.error(f\"Database error: {e}\")\n except Exception as e:\n logger.error(f\"Error in execute_batch_query: {e}\")\n return results\n\n def hierarchical_similarity_reranking(\n self,\n query_vector: np.ndarray,\n urls: List[str],\n limit: int = 100,\n ) -> List[AgentSearchResult]:\n \"\"\"Hierarchical URL search to find the most similar text chunk for the given query and URLs\"\"\"\n results = self.execute_batch_query(urls)\n # List to store the results along with their similarity scores\n similarity_results = []\n\n # Iterate over each result to find the most similar text chunk\n for result in results:\n (\n url,\n title,\n metadata,\n dataset,\n text_chunks_str,\n embeddings_binary,\n ) = result\n # deserialize the embeddings and text chunks\n embeddings = np.frombuffer(\n embeddings_binary, dtype=np.float32\n ).reshape(-1, 768)\n text_chunks = json.loads(text_chunks_str)\n max_similarity = -1e9\n most_similar_chunk = None\n\n # Iterate over each embedding to find the one with maximum cosine similarity\n for chunk, embedding in zip(text_chunks, embeddings):\n similarity = cosine_similarity(\n np.array(query_vector), np.array(embedding)\n )\n if similarity > max_similarity:\n max_similarity = similarity\n most_similar_chunk = chunk\n\n # Store the most similar chunk and its similarity score\n similarity_results.append(\n AgentSearchResult(\n score=max_similarity,\n url=url,\n title=title,\n metadata=json.loads(metadata),\n dataset=dataset,\n text=most_similar_chunk,\n ),\n )\n\n # Sort the results based on similarity score in descending order\n similarity_results.sort(key=lambda x: x.score, reverse=True)\n return similarity_results[:limit]\n\n def pagerank_reranking(\n self,\n similarity_results: List[AgentSearchResult],\n limit: int = 100,\n ) -> List[AgentSearchResult]:\n \"\"\"Reranks the results based on the PageRank score of the domain\"\"\"\n if not self.pagerank_rerank_module:\n raise Exception(\n \"PageRank reranking module is not enabled. Please set pagerank_rerank_module=True while initializing the WebSearchEngine client.\"\n )\n # List to store the results along with their PageRank scores\n pagerank_results = []\n\n # Iterate over each result to find the PageRank score of the domain\n for result in similarity_results:\n pagerank_score = 0\n try:\n domain = result.url.split(\"/\")[2]\n pagerank_score = self.domain_to_rank_map.get(domain, 0)\n except Exception as e:\n logger.info(f\"Error {e}: Found for URL: {result.url}\")\n reweighted_score = (\n self.pagerank_importance * pagerank_score / 10.0\n + (1 - self.pagerank_importance) * result.score\n )\n pagerank_results.append(\n AgentSearchResult(\n score=reweighted_score,\n url=result.url,\n title=result.title,\n metadata=result.metadata,\n dataset=result.dataset,\n text=result.text,\n )\n )\n\n # Sort the results based on PageRank score in descending order\n pagerank_results.sort(key=lambda x: x.score, reverse=True)\n return pagerank_results[:limit]" } ]

[ { "identifier": "constants", "path": "configs/constants.py", "snippet": "IMG_FEAT_DIM = {\n 'resnet': 2048,\n 'vit': 1024\n}\nN_JOINTS = 17\n PARSED_DATA = f'{root}/parsed_data'\n THREEDPW_PTH = f'{root}/3DPW'\n RICH_PTH = f'{root}/RICH'\n EMDB_PTH = f'{root}/EMDB'\n NUM_JOINTS = N_JOINTS\n H36M_TO_J17 = [6, 5, 4, 1, 2, 3, 16, 15, 14, 11, 12, 13, 8, 10, 0, 7, 9]\n H36M_TO_J14 = H36M_TO_J17[:14]\n J17_TO_H36M = [14, 3, 4, 5, 2, 1, 0, 15, 12, 16, 13, 9, 10, 11, 8, 7, 6]\n COCO_AUG_DICT = f'{root}/body_models/coco_aug_dict.pth'\n TREE = [[5, 6], 0, 0, 1, 2, -1, -1, 5, 6, 7, 8, -1, -1, 11, 12, 13, 14, 15, 15, 15, 16, 16, 16]\n S_BIAS = 1e-1\n S_JITTERING = 5e-2\n S_PEAK = 3e-1\n S_PEAK_MASK = 5e-3\n S_MASK = 0.03\n MAIN_JOINTS = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21] # reduced_joints\n FLDR = f'{root}/body_models/smpl/'\n SMPLX2SMPL = f'{root}/body_models/smplx2smpl.pkl'\n FACES = f'{root}/body_models/smpl_faces.npy'\n MEAN_PARAMS = f'{root}/body_models/smpl_mean_params.npz'\n JOINTS_REGRESSOR_WHAM = f'{root}/body_models/J_regressor_wham.npy'\n JOINTS_REGRESSOR_H36M = f'{root}/body_models/J_regressor_h36m.npy'\n JOINTS_REGRESSOR_EXTRA = f'{root}/body_models/J_regressor_extra.npy'\n JOINTS_REGRESSOR_FEET = f'{root}/body_models/J_regressor_feet.npy'\n PARENTS = torch.tensor([\n -1, 0, 0, 0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 9, 9, 12, 13, 14, 16, 17, 18, 19, 20, 21])\nclass PATHS:\nclass KEYPOINTS:\nclass BMODEL:" }, { "identifier": "rollout_global_motion", "path": "lib/models/layers/utils.py", "snippet": "def rollout_global_motion(root_r, root_v, init_trans=None):\n b, f = root_v.shape[:2]\n root = transforms.rotation_6d_to_matrix(root_r[:])\n vel_world = (root[:, :-1] @ root_v.unsqueeze(-1)).squeeze(-1)\n trans = torch.cumsum(vel_world, dim=1)\n \n if init_trans is not None: trans = trans + init_trans\n return root[:, 1:], trans" }, { "identifier": "axis_angle_to_matrix", "path": "lib/utils/transforms.py", "snippet": "def axis_angle_to_matrix(axis_angle: torch.Tensor) -> torch.Tensor:\n \"\"\"\n Convert rotations given as axis/angle to rotation matrices.\n\n Args:\n axis_angle: Rotations given as a vector in axis angle form,\n as a tensor of shape (..., 3), where the magnitude is\n the angle turned anticlockwise in radians around the\n vector's direction.\n\n Returns:\n Rotation matrices as tensor of shape (..., 3, 3).\n \"\"\"\n return quaternion_to_matrix(axis_angle_to_quaternion(axis_angle))" } ]

[ { "identifier": "xyz2key", "path": "serialization/z_order.py", "snippet": "def xyz2key(self, x, y, z, depth):\r\n key = torch.zeros_like(x)\r\n for i in range(depth):\r\n mask = 1 << i\r\n key = (\r\n key\r\n | ((x & mask) << (2 * i + 2))\r\n | ((y & mask) << (2 * i + 1))\r\n | ((z & mask) << (2 * i + 0))\r\n )\r\n return key\r" }, { "identifier": "key2xyz", "path": "serialization/z_order.py", "snippet": "def key2xyz(self, key, depth):\r\n x = torch.zeros_like(key)\r\n y = torch.zeros_like(key)\r\n z = torch.zeros_like(key)\r\n for i in range(depth):\r\n x = x | ((key & (1 << (3 * i + 2))) >> (2 * i + 2))\r\n y = y | ((key & (1 << (3 * i + 1))) >> (2 * i + 1))\r\n z = z | ((key & (1 << (3 * i + 0))) >> (2 * i + 0))\r\n return x, y, z\r" }, { "identifier": "encode", "path": "serialization/hilbert.py", "snippet": "def encode(locs, num_dims, num_bits):\r\n \"\"\"Decode an array of locations in a hypercube into a Hilbert integer.\r\n\r\n This is a vectorized-ish version of the Hilbert curve implementation by John\r\n Skilling as described in:\r\n\r\n Skilling, J. (2004, April). Programming the Hilbert curve. In AIP Conference\r\n Proceedings (Vol. 707, No. 1, pp. 381-387). American Institute of Physics.\r\n\r\n Params:\r\n -------\r\n locs - An ndarray of locations in a hypercube of num_dims dimensions, in\r\n which each dimension runs from 0 to 2**num_bits-1. The shape can\r\n be arbitrary, as long as the last dimension of the same has size\r\n num_dims.\r\n\r\n num_dims - The dimensionality of the hypercube. Integer.\r\n\r\n num_bits - The number of bits for each dimension. Integer.\r\n\r\n Returns:\r\n --------\r\n The output is an ndarray of uint64 integers with the same shape as the\r\n input, excluding the last dimension, which needs to be num_dims.\r\n \"\"\"\r\n\r\n # Keep around the original shape for later.\r\n orig_shape = locs.shape\r\n bitpack_mask = 1 << torch.arange(0, 8).to(locs.device)\r\n bitpack_mask_rev = bitpack_mask.flip(-1)\r\n\r\n if orig_shape[-1] != num_dims:\r\n raise ValueError(\r\n \"\"\"\r\n The shape of locs was surprising in that the last dimension was of size\r\n %d, but num_dims=%d. These need to be equal.\r\n \"\"\"\r\n % (orig_shape[-1], num_dims)\r\n )\r\n\r\n if num_dims * num_bits > 63:\r\n raise ValueError(\r\n \"\"\"\r\n num_dims=%d and num_bits=%d for %d bits total, which can't be encoded\r\n into a int64. Are you sure you need that many points on your Hilbert\r\n curve?\r\n \"\"\"\r\n % (num_dims, num_bits, num_dims * num_bits)\r\n )\r\n\r\n # Treat the location integers as 64-bit unsigned and then split them up into\r\n # a sequence of uint8s. Preserve the association by dimension.\r\n locs_uint8 = locs.long().view(torch.uint8).reshape((-1, num_dims, 8)).flip(-1)\r\n\r\n # Now turn these into bits and truncate to num_bits.\r\n gray = (\r\n locs_uint8.unsqueeze(-1)\r\n .bitwise_and(bitpack_mask_rev)\r\n .ne(0)\r\n .byte()\r\n .flatten(-2, -1)[..., -num_bits:]\r\n )\r\n\r\n # Run the decoding process the other way.\r\n # Iterate forwards through the bits.\r\n for bit in range(0, num_bits):\r\n # Iterate forwards through the dimensions.\r\n for dim in range(0, num_dims):\r\n # Identify which ones have this bit active.\r\n mask = gray[:, dim, bit]\r\n\r\n # Where this bit is on, invert the 0 dimension for lower bits.\r\n gray[:, 0, bit + 1 :] = torch.logical_xor(\r\n gray[:, 0, bit + 1 :], mask[:, None]\r\n )\r\n\r\n # Where the bit is off, exchange the lower bits with the 0 dimension.\r\n to_flip = torch.logical_and(\r\n torch.logical_not(mask[:, None]).repeat(1, gray.shape[2] - bit - 1),\r\n torch.logical_xor(gray[:, 0, bit + 1 :], gray[:, dim, bit + 1 :]),\r\n )\r\n gray[:, dim, bit + 1 :] = torch.logical_xor(\r\n gray[:, dim, bit + 1 :], to_flip\r\n )\r\n gray[:, 0, bit + 1 :] = torch.logical_xor(gray[:, 0, bit + 1 :], to_flip)\r\n\r\n # Now flatten out.\r\n gray = gray.swapaxes(1, 2).reshape((-1, num_bits * num_dims))\r\n\r\n # Convert Gray back to binary.\r\n hh_bin = gray2binary(gray)\r\n\r\n # Pad back out to 64 bits.\r\n extra_dims = 64 - num_bits * num_dims\r\n padded = torch.nn.functional.pad(hh_bin, (extra_dims, 0), \"constant\", 0)\r\n\r\n # Convert binary values into uint8s.\r\n hh_uint8 = (\r\n (padded.flip(-1).reshape((-1, 8, 8)) * bitpack_mask)\r\n .sum(2)\r\n .squeeze()\r\n .type(torch.uint8)\r\n )\r\n\r\n # Convert uint8s into uint64s.\r\n hh_uint64 = hh_uint8.view(torch.int64).squeeze()\r\n\r\n return hh_uint64\r" }, { "identifier": "decode", "path": "serialization/hilbert.py", "snippet": "def decode(hilberts, num_dims, num_bits):\r\n \"\"\"Decode an array of Hilbert integers into locations in a hypercube.\r\n\r\n This is a vectorized-ish version of the Hilbert curve implementation by John\r\n Skilling as described in:\r\n\r\n Skilling, J. (2004, April). Programming the Hilbert curve. In AIP Conference\r\n Proceedings (Vol. 707, No. 1, pp. 381-387). American Institute of Physics.\r\n\r\n Params:\r\n -------\r\n hilberts - An ndarray of Hilbert integers. Must be an integer dtype and\r\n cannot have fewer bits than num_dims * num_bits.\r\n\r\n num_dims - The dimensionality of the hypercube. Integer.\r\n\r\n num_bits - The number of bits for each dimension. Integer.\r\n\r\n Returns:\r\n --------\r\n The output is an ndarray of unsigned integers with the same shape as hilberts\r\n but with an additional dimension of size num_dims.\r\n \"\"\"\r\n\r\n if num_dims * num_bits > 64:\r\n raise ValueError(\r\n \"\"\"\r\n num_dims=%d and num_bits=%d for %d bits total, which can't be encoded\r\n into a uint64. Are you sure you need that many points on your Hilbert\r\n curve?\r\n \"\"\"\r\n % (num_dims, num_bits)\r\n )\r\n\r\n # Handle the case where we got handed a naked integer.\r\n hilberts = torch.atleast_1d(hilberts)\r\n\r\n # Keep around the shape for later.\r\n orig_shape = hilberts.shape\r\n bitpack_mask = 2 ** torch.arange(0, 8).to(hilberts.device)\r\n bitpack_mask_rev = bitpack_mask.flip(-1)\r\n\r\n # Treat each of the hilberts as a s equence of eight uint8.\r\n # This treats all of the inputs as uint64 and makes things uniform.\r\n hh_uint8 = (\r\n hilberts.ravel().type(torch.int64).view(torch.uint8).reshape((-1, 8)).flip(-1)\r\n )\r\n\r\n # Turn these lists of uints into lists of bits and then truncate to the size\r\n # we actually need for using Skilling's procedure.\r\n hh_bits = (\r\n hh_uint8.unsqueeze(-1)\r\n .bitwise_and(bitpack_mask_rev)\r\n .ne(0)\r\n .byte()\r\n .flatten(-2, -1)[:, -num_dims * num_bits :]\r\n )\r\n\r\n # Take the sequence of bits and Gray-code it.\r\n gray = binary2gray(hh_bits)\r\n\r\n # There has got to be a better way to do this.\r\n # I could index them differently, but the eventual packbits likes it this way.\r\n gray = gray.reshape((-1, num_bits, num_dims)).swapaxes(1, 2)\r\n\r\n # Iterate backwards through the bits.\r\n for bit in range(num_bits - 1, -1, -1):\r\n # Iterate backwards through the dimensions.\r\n for dim in range(num_dims - 1, -1, -1):\r\n # Identify which ones have this bit active.\r\n mask = gray[:, dim, bit]\r\n\r\n # Where this bit is on, invert the 0 dimension for lower bits.\r\n gray[:, 0, bit + 1 :] = torch.logical_xor(\r\n gray[:, 0, bit + 1 :], mask[:, None]\r\n )\r\n\r\n # Where the bit is off, exchange the lower bits with the 0 dimension.\r\n to_flip = torch.logical_and(\r\n torch.logical_not(mask[:, None]),\r\n torch.logical_xor(gray[:, 0, bit + 1 :], gray[:, dim, bit + 1 :]),\r\n )\r\n gray[:, dim, bit + 1 :] = torch.logical_xor(\r\n gray[:, dim, bit + 1 :], to_flip\r\n )\r\n gray[:, 0, bit + 1 :] = torch.logical_xor(gray[:, 0, bit + 1 :], to_flip)\r\n\r\n # Pad back out to 64 bits.\r\n extra_dims = 64 - num_bits\r\n padded = torch.nn.functional.pad(gray, (extra_dims, 0), \"constant\", 0)\r\n\r\n # Now chop these up into blocks of 8.\r\n locs_chopped = padded.flip(-1).reshape((-1, num_dims, 8, 8))\r\n\r\n # Take those blocks and turn them unto uint8s.\r\n # from IPython import embed; embed()\r\n locs_uint8 = (locs_chopped * bitpack_mask).sum(3).squeeze().type(torch.uint8)\r\n\r\n # Finally, treat these as uint64s.\r\n flat_locs = locs_uint8.view(torch.int64)\r\n\r\n # Return them in the expected shape.\r\n return flat_locs.reshape((*orig_shape, num_dims))\r" } ]

[ { "identifier": "TextProcessor", "path": "octo/data/utils/text_processing.py", "snippet": "class TextProcessor(ABC):\n \"\"\"\n Base class for text tokenization or text embedding.\n \"\"\"\n\n @abstractmethod\n def encode(self, strings: Sequence[str]):\n raise NotImplementedError" }, { "identifier": "ActionHead", "path": "octo/model/components/action_heads.py", "snippet": "class ActionHead(ABC):\n \"\"\"Action prediction modules that take in the transformer token outputs and predict actions.\n\n Each action head here does chunked action prediction: i.e. at every timestep,\n it tries to predict the next `pred_horizon` actions into the future from that timestep.\n Setting `pred_horizon=1` corresponds to the typical action prediction setup.\n \"\"\"\n\n @abstractmethod\n def loss(\n self,\n transformer_outputs: Dict[str, TokenGroup],\n actions: ArrayLike,\n pad_mask: ArrayLike,\n train: bool = True,\n ) -> Tuple[Array, Dict[str, Array]]:\n raise NotImplementedError\n\n @abstractmethod\n def predict_action(\n self,\n transformer_outputs: Dict[str, TokenGroup],\n argmax: bool = False,\n sample_shape: Tuple[int, ...] = (),\n rng: Optional[PRNGKey] = None,\n temperature: float = 1.0,\n train: bool = False,\n ) -> Array:\n \"\"\"Predict the action for the last timestep in the window. Returns shape\n (*sample_shape, batch_size, pred_horizon, action_dim).\n \"\"\"\n raise NotImplementedError" }, { "identifier": "OctoModule", "path": "octo/model/octo_module.py", "snippet": "class OctoModule(nn.Module):\n \"\"\"\n Bundles OctoTransformer with various heads (useful for keeping all parameters in one place).\n \"\"\"\n\n octo_transformer: OctoTransformer\n heads: Dict[str, nn.Module]\n\n def __call__(self, observations, tasks, pad_mask, train=True, verbose=False):\n \"\"\"Run transformer and the main method for all heads. Useful for init.\n\n Args:\n observations: A dictionary containing observation data\n where each element has shape (batch, horizon, *).\n tasks: A dictionary containing task data\n where each element has shape (batch, *).\n pad_mask: A boolean mask of shape (batch, horizon) where False indicates a padded timestep.\n train: Run in training mode\n verbose: If True, prints out the structure of the OctoTransformer (useful for debugging!)\n\n Returns:\n transformer_outputs: See OctoTransformer.__call__\n head_outputs: dictionary of outputs from heads {head_name: output}\n \"\"\"\n transformer_outputs = self.octo_transformer(\n observations, tasks, pad_mask, train=train, verbose=verbose\n )\n head_outputs = {}\n for head_name, head in self.heads.items():\n head_outputs[head_name] = head(transformer_outputs, train=train)\n return transformer_outputs, head_outputs\n\n @classmethod\n def create(\n cls,\n observation_tokenizers: Dict[str, ModuleSpec],\n task_tokenizers: Dict[str, ModuleSpec],\n heads: Dict[str, ModuleSpec],\n readouts: Dict[str, int],\n transformer_kwargs: Dict,\n token_embedding_size: int,\n max_horizon: int,\n ) -> \"OctoModule\":\n \"\"\"\n Canonical way to create an OctoModule from configuration.\n\n Args:\n observation_tokenizers: dict of {tokenizer_name: tokenizer_spec} (see tokenizers.py)\n task_tokenizers: dict of {tokenizer_name: tokenizer_spec} (see tokenizers.py)\n heads: dict of {head_name: head_spec} (see heads.py)\n readouts: dict of {readout_name (str): n_tokens_for_readout (int)}\n token_embedding_size (int): The latent dimension of the token embeddings\n max_horizon (int): Sets the size of positional embeddings, and provides an upper limit on the\n maximum horizon of the model\n transformer_kwargs: additional kwargs to forward to the transformer, which include:\n num_layers (int): number of layers\n mlp_dim (int): hidden dimension of the MLPs\n num_heads (int): Number of heads in nn.MultiHeadDotProductAttention\n dropout_rate (float): dropout rate.\n attention_dropout_rate (float): dropout rate in self attention.\n \"\"\"\n\n observation_tokenizer_defs = {\n k: ModuleSpec.instantiate(spec)()\n for k, spec in observation_tokenizers.items()\n }\n task_tokenizer_defs = {\n k: ModuleSpec.instantiate(spec)() for k, spec in task_tokenizers.items()\n }\n\n head_defs = {k: ModuleSpec.instantiate(spec)() for k, spec in heads.items()}\n\n model_def = OctoTransformer(\n observation_tokenizers=observation_tokenizer_defs,\n task_tokenizers=task_tokenizer_defs,\n readouts=readouts,\n token_embedding_size=token_embedding_size,\n max_horizon=max_horizon,\n transformer_kwargs=transformer_kwargs,\n )\n\n return cls(\n octo_transformer=model_def,\n heads=head_defs,\n )" }, { "identifier": "ModuleSpec", "path": "octo/utils/spec.py", "snippet": "class ModuleSpec(TypedDict):\n \"\"\"A JSON-serializable representation of a function or class with some default args and kwargs to pass to\n it. Useful for specifying a particular class or function in a config file, while keeping it serializable\n and overridable from the command line using ml_collections.\n\n Usage:\n\n # Preferred way to create a spec:\n >>> from octo.model.components.transformer import Transformer\n >>> spec = ModuleSpec.create(Transformer, num_layers=3)\n # Same as above using the fully qualified import string:\n >>> spec = ModuleSpec.create(\"octo.model.components.transformer:Transformer\", num_layers=3)\n\n # Usage:\n >>> ModuleSpec.instantiate(spec) == partial(Transformer, num_layers=3)\n # can pass additional kwargs at instantiation time\n >>> transformer = ModuleSpec.instantiate(spec, num_heads=8)\n\n Note: ModuleSpec is just an alias for a dictionary (that is strongly typed), not a real class. So from\n your code's perspective, it is just a dictionary.\n\n module (str): The module the callable is located in\n name (str): The name of the callable in the module\n args (tuple): The args to pass to the callable\n kwargs (dict): The kwargs to pass to the callable\n \"\"\"\n\n module: str\n name: str\n args: Tuple[Any, ...]\n kwargs: Dict[str, Any]\n\n @staticmethod\n def create(callable_or_full_name: Union[str, callable], *args, **kwargs) -> \"ModuleSpec\": # type: ignore\n \"\"\"Create a module spec from a callable or import string.\n\n Args:\n callable_or_full_name (str or object): Either the object itself or a fully qualified import string\n (e.g. \"octo.model.components.transformer:Transformer\")\n args (tuple, optional): Passed into callable upon instantiation.\n kwargs (dict, optional): Passed into callable upon instantiation.\n \"\"\"\n if isinstance(callable_or_full_name, str):\n assert callable_or_full_name.count(\":\") == 1, (\n \"If passing in a string, it must be a fully qualified import string \"\n \"(e.g. 'octo.model.components.transformer:Transformer')\"\n )\n module, name = callable_or_full_name.split(\":\")\n else:\n module, name = _infer_full_name(callable_or_full_name)\n\n return ModuleSpec(module=module, name=name, args=args, kwargs=kwargs)\n\n @staticmethod\n def instantiate(spec: \"ModuleSpec\"): # type: ignore\n if set(spec.keys()) != {\"module\", \"name\", \"args\", \"kwargs\"}:\n raise ValueError(\n f\"Expected ModuleSpec, but got {spec}. \"\n \"ModuleSpec must have keys 'module', 'name', 'args', and 'kwargs'.\"\n )\n cls = _import_from_string(spec[\"module\"], spec[\"name\"])\n return partial(cls, *spec[\"args\"], **spec[\"kwargs\"])" }, { "identifier": "Config", "path": "octo/utils/typing.py", "snippet": "" } ]

[ { "identifier": "geom", "path": "utils/geom.py", "snippet": "def eye_4x4(B, device='cuda'):\ndef safe_inverse(a): #parallel version\ndef safe_inverse_single(a):\ndef apply_4x4(RT, xyz):\ndef get_camM_T_camXs(origin_T_camXs, ind=0):\ndef split_rt_single(rt):\ndef split_rt(rt):\ndef merge_rt(r, t):\ndef xyd2pointcloud(xyd, pix_T_cam):\ndef pixels2camera(x, y, z, fx, fy, x0, y0):\ndef camera2pixels(xyz, pix_T_cam):\ndef scale_intrinsics(K, sx, sy):\ndef split_intrinsics(K):\ndef merge_intrinsics(fx, fy, x0, y0):\ndef merge_rtlist(rlist, tlist):\ndef split_lrtlist(lrtlist):\ndef merge_lrtlist(lenlist, rtlist):\ndef apply_4x4_to_lrtlist(Y_T_X, lrtlist_X):\ndef apply_4x4_to_lrt(Y_T_X, lrt_X):\ndef get_xyzlist_from_lenlist(lenlist):\ndef get_xyzlist_from_lrtlist(lrtlist, include_clist=False):\ndef get_clist_from_lrtlist(lrtlist):\ndef wrap2pi(rad_angle):\ndef unproject(cam2world, intrinsic, depth):\ndef reproject(cam2world_src, cam2world_tar, W, H, intrinsic, depth_src, depth_tar, color_tar, mask_tar):\n def make_grid(x, y):\ndef visualize_depth(depth, mask=None, depth_min=None, depth_max=None, direct=False):\ndef mat2pose_vec(matrix: torch.Tensor):\ndef square_distance(src, dst):\n B, _, _ = list(a.shape)\n B, N, _ = list(xyz.shape)\n B, S = list(origin_T_camXs.shape)[0:2]\n B, C, D = list(r.shape)\n B2, D2 = list(t.shape)\n B, N, C = list(xyd.shape)\n B = x.shape[0]\n B = list(z.shape)[0]\n EPS = 1e-4\n K = merge_intrinsics(fx, fy, x0, y0)\n B = list(fx.shape)[0]\n K = torch.zeros(B, 4, 4, dtype=torch.float32, device=fx.device)\n K[:,0,0] = fx\n K[:,1,1] = fy\n K[:,0,2] = x0\n K[:,1,2] = y0\n K[:,2,2] = 1.0\n K[:,3,3] = 1.0\n B, N, D, E = list(rlist.shape)\n B, N, F = list(tlist.shape)\n B, N, D = list(lrtlist.shape)\n B, N, D = list(lenlist.shape)\n B2, N2, E, F = list(rtlist.shape)\n B, N, D = list(lrtlist_X.shape)\n B2, E, F = list(Y_T_X.shape)\n B, D = list(lrt_X.shape)\n B2, E, F = list(Y_T_X.shape)\n B, N, D = list(lenlist.shape)\n B, N, D = list(lrtlist.shape)\n B, N, D = list(lrtlist.shape)\n B, N, _ = src.shape\n _, M, _ = dst.shape" }, { "identifier": "basic", "path": "utils/basic.py", "snippet": "EPS = 1e-6\n B_, S = shapelist[:2]\n BS = shapelist[0]\n S = int(BS/B)\ndef strnum(x):\ndef matmul2(mat1, mat2):\ndef pack_seqdim(tensor, B):\ndef unpack_seqdim(tensor, B):\ndef reduce_masked_mean(x, mask, dim=None, keepdim=False):\ndef meshgrid3d(B, Z, Y, X, stack=False, norm=False, device='cuda'):\ndef gridcloud3d(B, Z, Y, X, norm=False, device='cuda'):\ndef normalize_grid2d(grid_y, grid_x, Y, X, clamp_extreme=True):" }, { "identifier": "render", "path": "utils/render.py", "snippet": "def get_rays(H, W, K, c2w, inverse_y, flip_x, flip_y, mode='center'):\ndef ndc_rays(H, W, focal, near, rays_o, rays_d):\ndef get_rays_of_a_view(H, W, K, c2w, ndc, inverse_y, flip_x, flip_y, mode='center'):\ndef cumprod_exclusive(p):\ndef get_ray_marching_ray(alpha):\ndef sample_ray(self, rays_o, rays_d, near, far, stepsize, xyz_min, xyz_max, voxel_size, is_train=False):\n def __init__(self, init_val, beta_min=0.0001):\n def forward(self, sdf, beta=None):\n def get_beta(self):\n def __init__(self, init_val, beta_min=0.0001):\n def forward(self, sdf, beta=None):\n def get_beta(self):\n def __init__(self, init_val):\n def forward(self, x):\n def get_variance(self):\nclass SigmoidDensity(nn.Module): # alpha * Laplace(loc=0, scale=beta).cdf(-sdf)\nclass LaplaceDensity(nn.Module): # alpha * Laplace(loc=0, scale=beta).cdf(-sdf)\nclass SingleVarianceNetwork(nn.Module):" } ]

[ { "identifier": "BaseGeometry", "path": "threestudio/models/geometry/base.py", "snippet": "class BaseGeometry(BaseModule):\n @dataclass\n class Config(BaseModule.Config):\n pass\n\n cfg: Config\n\n @staticmethod\n def create_from(\n other: \"BaseGeometry\", cfg: Optional[Union[dict, DictConfig]] = None, **kwargs\n ) -> \"BaseGeometry\":\n raise TypeError(\n f\"Cannot create {BaseGeometry.__name__} from {other.__class__.__name__}\"\n )\n\n def export(self, *args, **kwargs) -> Dict[str, Any]:\n return {}" }, { "identifier": "BaseImplicitGeometry", "path": "threestudio/models/geometry/base.py", "snippet": "class BaseImplicitGeometry(BaseGeometry):\n @dataclass\n class Config(BaseGeometry.Config):\n radius: float = 1.0\n isosurface: bool = True\n isosurface_method: str = \"mt\"\n isosurface_resolution: int = 128\n isosurface_threshold: Union[float, str] = 0.0\n isosurface_chunk: int = 0\n isosurface_coarse_to_fine: bool = True\n isosurface_deformable_grid: bool = False\n isosurface_remove_outliers: bool = True\n isosurface_outlier_n_faces_threshold: Union[int, float] = 0.01\n\n cfg: Config\n\n def configure(self) -> None:\n self.bbox: Float[Tensor, \"2 3\"]\n self.register_buffer(\n \"bbox\",\n torch.as_tensor(\n [\n [-self.cfg.radius, -self.cfg.radius, -self.cfg.radius],\n [self.cfg.radius, self.cfg.radius, self.cfg.radius],\n ],\n dtype=torch.float32,\n ),\n )\n self.isosurface_helper: Optional[IsosurfaceHelper] = None\n self.unbounded: bool = False\n\n def _initilize_isosurface_helper(self):\n if self.cfg.isosurface and self.isosurface_helper is None:\n if self.cfg.isosurface_method == \"mc-cpu\":\n self.isosurface_helper = MarchingCubeCPUHelper(\n self.cfg.isosurface_resolution\n ).to(self.device)\n elif self.cfg.isosurface_method == \"mt\":\n self.isosurface_helper = MarchingTetrahedraHelper(\n self.cfg.isosurface_resolution,\n f\"load/tets/{self.cfg.isosurface_resolution}_tets.npz\",\n ).to(self.device)\n else:\n raise AttributeError(\n \"Unknown isosurface method {self.cfg.isosurface_method}\"\n )\n\n def forward(\n self, points: Float[Tensor, \"*N Di\"], output_normal: bool = False\n ) -> Dict[str, Float[Tensor, \"...\"]]:\n raise NotImplementedError\n\n def forward_field(\n self, points: Float[Tensor, \"*N Di\"]\n ) -> Tuple[Float[Tensor, \"*N 1\"], Optional[Float[Tensor, \"*N 3\"]]]:\n # return the value of the implicit field, could be density / signed distance\n # also return a deformation field if the grid vertices can be optimized\n raise NotImplementedError\n\n def forward_level(\n self, field: Float[Tensor, \"*N 1\"], threshold: float\n ) -> Float[Tensor, \"*N 1\"]:\n # return the value of the implicit field, where the zero level set represents the surface\n raise NotImplementedError\n\n def _isosurface(self, bbox: Float[Tensor, \"2 3\"], fine_stage: bool = False) -> Mesh:\n def batch_func(x):\n # scale to bbox as the input vertices are in [0, 1]\n field, deformation = self.forward_field(\n scale_tensor(\n x.to(bbox.device), self.isosurface_helper.points_range, bbox\n ),\n )\n field = field.to(\n x.device\n ) # move to the same device as the input (could be CPU)\n if deformation is not None:\n deformation = deformation.to(x.device)\n return field, deformation\n\n assert self.isosurface_helper is not None\n\n field, deformation = chunk_batch(\n batch_func,\n self.cfg.isosurface_chunk,\n self.isosurface_helper.grid_vertices,\n )\n\n threshold: float\n\n if isinstance(self.cfg.isosurface_threshold, float):\n threshold = self.cfg.isosurface_threshold\n elif self.cfg.isosurface_threshold == \"auto\":\n eps = 1.0e-5\n threshold = field[field > eps].mean().item()\n threestudio.info(\n f\"Automatically determined isosurface threshold: {threshold}\"\n )\n else:\n raise TypeError(\n f\"Unknown isosurface_threshold {self.cfg.isosurface_threshold}\"\n )\n\n level = self.forward_level(field, threshold)\n mesh: Mesh = self.isosurface_helper(level, deformation=deformation)\n mesh.v_pos = scale_tensor(\n mesh.v_pos, self.isosurface_helper.points_range, bbox\n ) # scale to bbox as the grid vertices are in [0, 1]\n mesh.add_extra(\"bbox\", bbox)\n\n if self.cfg.isosurface_remove_outliers:\n # remove outliers components with small number of faces\n # only enabled when the mesh is not differentiable\n mesh = mesh.remove_outlier(self.cfg.isosurface_outlier_n_faces_threshold)\n\n return mesh\n\n def isosurface(self) -> Mesh:\n if not self.cfg.isosurface:\n raise NotImplementedError(\n \"Isosurface is not enabled in the current configuration\"\n )\n self._initilize_isosurface_helper()\n if self.cfg.isosurface_coarse_to_fine:\n threestudio.debug(\"First run isosurface to get a tight bounding box ...\")\n with torch.no_grad():\n mesh_coarse = self._isosurface(self.bbox)\n vmin, vmax = mesh_coarse.v_pos.amin(dim=0), mesh_coarse.v_pos.amax(dim=0)\n vmin_ = (vmin - (vmax - vmin) * 0.1).max(self.bbox[0])\n vmax_ = (vmax + (vmax - vmin) * 0.1).min(self.bbox[1])\n threestudio.debug(\"Run isosurface again with the tight bounding box ...\")\n mesh = self._isosurface(torch.stack([vmin_, vmax_], dim=0), fine_stage=True)\n else:\n mesh = self._isosurface(self.bbox)\n return mesh" }, { "identifier": "contract_to_unisphere", "path": "threestudio/models/geometry/base.py", "snippet": "def contract_to_unisphere(\n x: Float[Tensor, \"... 3\"], bbox: Float[Tensor, \"2 3\"], unbounded: bool = False\n) -> Float[Tensor, \"... 3\"]:\n if unbounded:\n x = scale_tensor(x, bbox, (0, 1))\n x = x * 2 - 1 # aabb is at [-1, 1]\n mag = x.norm(dim=-1, keepdim=True)\n mask = mag.squeeze(-1) > 1\n x[mask] = (2 - 1 / mag[mask]) * (x[mask] / mag[mask])\n x = x / 4 + 0.5 # [-inf, inf] is at [0, 1]\n else:\n x = scale_tensor(x, bbox, (0, 1))\n return x" }, { "identifier": "get_encoding", "path": "threestudio/models/networks.py", "snippet": "def get_encoding(n_input_dims: int, config) -> nn.Module:\n # input suppose to be range [0, 1]\n encoding: nn.Module\n if config.otype == \"ProgressiveBandFrequency\":\n encoding = ProgressiveBandFrequency(n_input_dims, config_to_primitive(config))\n elif config.otype == \"ProgressiveBandHashGrid\":\n encoding = ProgressiveBandHashGrid(n_input_dims, config_to_primitive(config))\n else:\n encoding = TCNNEncoding(n_input_dims, config_to_primitive(config))\n encoding = CompositeEncoding(\n encoding,\n include_xyz=config.get(\"include_xyz\", False),\n xyz_scale=2.0,\n xyz_offset=-1.0,\n ) # FIXME: hard coded\n return encoding" }, { "identifier": "get_mlp", "path": "threestudio/models/networks.py", "snippet": "def get_mlp(n_input_dims, n_output_dims, config) -> nn.Module:\n network: nn.Module\n if config.otype == \"VanillaMLP\":\n network = VanillaMLP(n_input_dims, n_output_dims, config_to_primitive(config))\n elif config.otype == \"SphereInitVanillaMLP\":\n network = SphereInitVanillaMLP(\n n_input_dims, n_output_dims, config_to_primitive(config)\n )\n else:\n assert (\n config.get(\"sphere_init\", False) is False\n ), \"sphere_init=True only supported by VanillaMLP\"\n network = TCNNNetwork(n_input_dims, n_output_dims, config_to_primitive(config))\n return network" }, { "identifier": "get_activation", "path": "threestudio/utils/ops.py", "snippet": "def get_activation(name) -> Callable:\n if name is None:\n return lambda x: x\n name = name.lower()\n if name == \"none\":\n return lambda x: x\n elif name == \"lin2srgb\":\n return lambda x: torch.where(\n x > 0.0031308,\n torch.pow(torch.clamp(x, min=0.0031308), 1.0 / 2.4) * 1.055 - 0.055,\n 12.92 * x,\n ).clamp(0.0, 1.0)\n elif name == \"exp\":\n return lambda x: torch.exp(x)\n elif name == \"shifted_exp\":\n return lambda x: torch.exp(x - 1.0)\n elif name == \"trunc_exp\":\n return trunc_exp\n elif name == \"shifted_trunc_exp\":\n return lambda x: trunc_exp(x - 1.0)\n elif name == \"sigmoid\":\n return lambda x: torch.sigmoid(x)\n elif name == \"tanh\":\n return lambda x: torch.tanh(x)\n elif name == \"shifted_softplus\":\n return lambda x: F.softplus(x - 1.0)\n elif name == \"scale_-11_01\":\n return lambda x: x * 0.5 + 0.5\n else:\n try:\n return getattr(F, name)\n except AttributeError:\n raise ValueError(f\"Unknown activation function: {name}\")" } ]

[ { "identifier": "is_module_wrapper", "path": "annotator/mmpkg/mmcv/parallel/utils.py", "snippet": "def is_module_wrapper(module):\n \"\"\"Check if a module is a module wrapper.\n\n The following 3 modules in MMCV (and their subclasses) are regarded as\n module wrappers: DataParallel, DistributedDataParallel,\n MMDistributedDataParallel (the deprecated version). You may add you own\n module wrapper by registering it to mmcv.parallel.MODULE_WRAPPERS.\n\n Args:\n module (nn.Module): The module to be checked.\n\n Returns:\n bool: True if the input module is a module wrapper.\n \"\"\"\n module_wrappers = tuple(MODULE_WRAPPERS.module_dict.values())\n return isinstance(module, module_wrappers)" }, { "identifier": "load_checkpoint", "path": "annotator/mmpkg/mmcv/runner/checkpoint.py", "snippet": "@classmethod\ndef load_checkpoint(cls, filename, map_location=None, logger=None):\n \"\"\"load checkpoint through URL scheme path.\n\n Args:\n filename (str): checkpoint file name with given prefix\n map_location (str, optional): Same as :func:`torch.load`.\n Default: None\n logger (:mod:`logging.Logger`, optional): The logger for message.\n Default: None\n\n Returns:\n dict or OrderedDict: The loaded checkpoint.\n \"\"\"\n\n checkpoint_loader = cls._get_checkpoint_loader(filename)\n class_name = checkpoint_loader.__name__\n mmcv.print_log(\n f'load checkpoint from {class_name[10:]} path: {filename}', logger)\n return checkpoint_loader(filename, map_location)" }, { "identifier": "get_dist_info", "path": "annotator/mmpkg/mmcv/runner/dist_utils.py", "snippet": "def get_dist_info():\n if dist.is_available() and dist.is_initialized():\n rank = dist.get_rank()\n world_size = dist.get_world_size()\n else:\n rank = 0\n world_size = 1\n return rank, world_size" }, { "identifier": "HOOKS", "path": "annotator/mmpkg/mmcv/runner/hooks/hook.py", "snippet": "HOOKS = Registry('hook')" }, { "identifier": "Hook", "path": "annotator/mmpkg/mmcv/runner/hooks/hook.py", "snippet": "class Hook:\n stages = ('before_run', 'before_train_epoch', 'before_train_iter',\n 'after_train_iter', 'after_train_epoch', 'before_val_epoch',\n 'before_val_iter', 'after_val_iter', 'after_val_epoch',\n 'after_run')\n\n def before_run(self, runner):\n pass\n\n def after_run(self, runner):\n pass\n\n def before_epoch(self, runner):\n pass\n\n def after_epoch(self, runner):\n pass\n\n def before_iter(self, runner):\n pass\n\n def after_iter(self, runner):\n pass\n\n def before_train_epoch(self, runner):\n self.before_epoch(runner)\n\n def before_val_epoch(self, runner):\n self.before_epoch(runner)\n\n def after_train_epoch(self, runner):\n self.after_epoch(runner)\n\n def after_val_epoch(self, runner):\n self.after_epoch(runner)\n\n def before_train_iter(self, runner):\n self.before_iter(runner)\n\n def before_val_iter(self, runner):\n self.before_iter(runner)\n\n def after_train_iter(self, runner):\n self.after_iter(runner)\n\n def after_val_iter(self, runner):\n self.after_iter(runner)\n\n def every_n_epochs(self, runner, n):\n return (runner.epoch + 1) % n == 0 if n > 0 else False\n\n def every_n_inner_iters(self, runner, n):\n return (runner.inner_iter + 1) % n == 0 if n > 0 else False\n\n def every_n_iters(self, runner, n):\n return (runner.iter + 1) % n == 0 if n > 0 else False\n\n def end_of_epoch(self, runner):\n return runner.inner_iter + 1 == len(runner.data_loader)\n\n def is_last_epoch(self, runner):\n return runner.epoch + 1 == runner._max_epochs\n\n def is_last_iter(self, runner):\n return runner.iter + 1 == runner._max_iters\n\n def get_triggered_stages(self):\n trigger_stages = set()\n for stage in Hook.stages:\n if is_method_overridden(stage, Hook, self):\n trigger_stages.add(stage)\n\n # some methods will be triggered in multi stages\n # use this dict to map method to stages.\n method_stages_map = {\n 'before_epoch': ['before_train_epoch', 'before_val_epoch'],\n 'after_epoch': ['after_train_epoch', 'after_val_epoch'],\n 'before_iter': ['before_train_iter', 'before_val_iter'],\n 'after_iter': ['after_train_iter', 'after_val_iter'],\n }\n\n for method, map_stages in method_stages_map.items():\n if is_method_overridden(method, Hook, self):\n trigger_stages.update(map_stages)\n\n return [stage for stage in Hook.stages if stage in trigger_stages]" }, { "identifier": "LogBuffer", "path": "annotator/mmpkg/mmcv/runner/log_buffer.py", "snippet": "class LogBuffer:\n\n def __init__(self):\n self.val_history = OrderedDict()\n self.n_history = OrderedDict()\n self.output = OrderedDict()\n self.ready = False\n\n def clear(self):\n self.val_history.clear()\n self.n_history.clear()\n self.clear_output()\n\n def clear_output(self):\n self.output.clear()\n self.ready = False\n\n def update(self, vars, count=1):\n assert isinstance(vars, dict)\n for key, var in vars.items():\n if key not in self.val_history:\n self.val_history[key] = []\n self.n_history[key] = []\n self.val_history[key].append(var)\n self.n_history[key].append(count)\n\n def average(self, n=0):\n \"\"\"Average latest n values or all values.\"\"\"\n assert n >= 0\n for key in self.val_history:\n values = np.array(self.val_history[key][-n:])\n nums = np.array(self.n_history[key][-n:])\n avg = np.sum(values * nums) / np.sum(nums)\n self.output[key] = avg\n self.ready = True" }, { "identifier": "Priority", "path": "annotator/mmpkg/mmcv/runner/priority.py", "snippet": "class Priority(Enum):\n \"\"\"Hook priority levels.\n\n +--------------+------------+\n | Level | Value |\n +==============+============+\n | HIGHEST | 0 |\n +--------------+------------+\n | VERY_HIGH | 10 |\n +--------------+------------+\n | HIGH | 30 |\n +--------------+------------+\n | ABOVE_NORMAL | 40 |\n +--------------+------------+\n | NORMAL | 50 |\n +--------------+------------+\n | BELOW_NORMAL | 60 |\n +--------------+------------+\n | LOW | 70 |\n +--------------+------------+\n | VERY_LOW | 90 |\n +--------------+------------+\n | LOWEST | 100 |\n +--------------+------------+\n \"\"\"\n\n HIGHEST = 0\n VERY_HIGH = 10\n HIGH = 30\n ABOVE_NORMAL = 40\n NORMAL = 50\n BELOW_NORMAL = 60\n LOW = 70\n VERY_LOW = 90\n LOWEST = 100" }, { "identifier": "get_priority", "path": "annotator/mmpkg/mmcv/runner/priority.py", "snippet": "def get_priority(priority):\n \"\"\"Get priority value.\n\n Args:\n priority (int or str or :obj:`Priority`): Priority.\n\n Returns:\n int: The priority value.\n \"\"\"\n if isinstance(priority, int):\n if priority < 0 or priority > 100:\n raise ValueError('priority must be between 0 and 100')\n return priority\n elif isinstance(priority, Priority):\n return priority.value\n elif isinstance(priority, str):\n return Priority[priority.upper()].value\n else:\n raise TypeError('priority must be an integer or Priority enum value')" }, { "identifier": "get_time_str", "path": "annotator/mmpkg/mmcv/runner/utils.py", "snippet": "def get_time_str():\n return time.strftime('%Y%m%d_%H%M%S', time.localtime())" } ]

[ { "identifier": "area_of_circular_segment", "path": "tests/unit_tests/utils.py", "snippet": "def area_of_circular_segment(circle_radius: float, delta_height: float) -> float:\n \"\"\"Compute the area of a circular segment (see source for definition).\n\n Source: https://en.wikipedia.org/wiki/Circular_segment\n\n Args:\n circle_radius (float): Radius of the circle (R).\n delta_height (float): distance between the center of the segment and the base of the secant, i.e. apothem (d).\n\n Returns:\n float: area of the circular segment\n \"\"\"\n if delta_height > circle_radius:\n return 0.0\n area = circle_radius**2 * np.arccos(delta_height / circle_radius) - delta_height * np.sqrt(\n circle_radius**2 - delta_height**2\n )\n return area" }, { "identifier": "generate_arc", "path": "tests/unit_tests/utils.py", "snippet": "def generate_arc(\n radius: float, center_x: float, center_y: float, from_angle: float, to_angle: float, num_points: int = 1000\n) -> np.ndarray:\n angles = np.linspace(from_angle, to_angle, num_points, endpoint=not (from_angle == 0.0 and to_angle == 2 * np.pi))\n\n circle_xs = radius * np.cos(angles) + center_x\n circle_ys = radius * np.sin(angles) + center_y\n\n return np.column_stack([circle_xs, circle_ys])" }, { "identifier": "rotated_asymmetric_rectangle", "path": "tests/unit_tests/utils.py", "snippet": "def rotated_asymmetric_rectangle(\n center_x: float, center_y: float, semi_width: float, upper_height: float, lower_height: float, angle: float\n) -> np.ndarray:\n \"\"\"Compute a rotated rectangle with different upper and lower semi-heights.\n\n Args:\n center_x (float): X coordinates of the center of the asymmetric rectangle.\n center_y (float): Y coordinates of the center of the asymmetric rectangle\n semi_width (float): half of the rectangle width.\n upper_height (float): distance from the center of the rectangle to the upper edge.\n lower_height (float): distance from the center of the rectangle to the lower edge.\n angle (float): angle of rotation in radians.\n\n Returns:\n np.ndarray: rotated rectangle array.\n \"\"\"\n return np.array(\n [\n [\n center_x + semi_width * np.cos(angle) + upper_height * np.cos(np.pi / 2 + angle),\n center_y + semi_width * np.sin(angle) + upper_height * np.sin(np.pi / 2 + angle),\n ],\n [\n center_x + semi_width * np.cos(angle) - lower_height * np.cos(np.pi / 2 + angle),\n center_y + semi_width * np.sin(angle) - lower_height * np.sin(np.pi / 2 + angle),\n ],\n [\n center_x - semi_width * np.cos(angle) - lower_height * np.cos(np.pi / 2 + angle),\n center_y - semi_width * np.sin(angle) - lower_height * np.sin(np.pi / 2 + angle),\n ],\n [\n center_x - semi_width * np.cos(angle) + upper_height * np.cos(np.pi / 2 + angle),\n center_y - semi_width * np.sin(angle) + upper_height * np.sin(np.pi / 2 + angle),\n ],\n ]\n )" } ]

[ { "identifier": "custom_prepare_latents", "path": "relighting/pipeline_utils.py", "snippet": "def custom_prepare_latents(\n self,\n batch_size,\n num_channels_latents,\n height,\n width,\n dtype,\n device,\n generator,\n latents=None,\n image=None,\n timestep=None,\n is_strength_max=True,\n use_noise_moving=True,\n return_noise=False,\n return_image_latents=False,\n newx=0,\n newy=0,\n newr=256,\n current_seed=None,\n ):\n shape = (batch_size, num_channels_latents, height // self.vae_scale_factor, width // self.vae_scale_factor)\n if isinstance(generator, list) and len(generator) != batch_size:\n raise ValueError(\n f\"You have passed a list of generators of length {len(generator)}, but requested an effective batch\"\n f\" size of {batch_size}. Make sure the batch size matches the length of the generators.\"\n )\n\n if (image is None or timestep is None) and not is_strength_max:\n raise ValueError(\n \"Since strength < 1. initial latents are to be initialised as a combination of Image + Noise.\"\n \"However, either the image or the noise timestep has not been provided.\"\n )\n\n if image.shape[1] == 4:\n image_latents = image.to(device=device, dtype=dtype)\n elif return_image_latents or (latents is None and not is_strength_max):\n image = image.to(device=device, dtype=dtype)\n image_latents = self._encode_vae_image(image=image, generator=generator)\n\n if latents is None and use_noise_moving:\n # random big noise map\n noise = randn_tensor(shape, generator=generator, device=device, dtype=dtype)\n noise = expand_noise(noise, shape, seed=current_seed, device=device, dtype=dtype)\n \n # ensure noise is the same regardless of inpainting location (top-left corner notation)\n newys = [newy] if not isinstance(newy, list) else newy\n newxs = [newx] if not isinstance(newx, list) else newx\n big_noise = noise.clone()\n prev_noise = None\n for newy, newx in zip(newys, newxs):\n # find patch location within big noise map\n sy = big_noise.shape[2] // 4 + ((512 - 128) - newy) // self.vae_scale_factor\n sx = big_noise.shape[3] // 4 + ((512 - 128) - newx) // self.vae_scale_factor\n\n if prev_noise is not None:\n new_noise = big_noise[:, :, sy:sy+shape[2], sx:sx+shape[3]]\n\n ball_mask = torch.zeros(shape, device=device, dtype=bool)\n top_left = (newy // self.vae_scale_factor, newx // self.vae_scale_factor)\n bottom_right = (top_left[0] + newr // self.vae_scale_factor, top_left[1] + newr // self.vae_scale_factor) # fixed ball size r = 256\n ball_mask[:, :, top_left[0]:bottom_right[0], top_left[1]:bottom_right[1]] = True\n\n noise = prev_noise.clone()\n noise[ball_mask] = new_noise[ball_mask]\n else:\n noise = big_noise[:, :, sy:sy+shape[2], sx:sx+shape[3]]\n\n prev_noise = noise.clone()\n\n # if strength is 1. then initialise the latents to noise, else initial to image + noise\n latents = noise if is_strength_max else self.scheduler.add_noise(image_latents, noise, timestep)\n # if pure noise then scale the initial latents by the Scheduler's init sigma\n latents = latents * self.scheduler.init_noise_sigma if is_strength_max else latents\n elif latents is None:\n noise = randn_tensor(shape, generator=generator, device=device, dtype=dtype)\n latents = image_latents.to(device)\n else:\n noise = latents.to(device)\n latents = noise * self.scheduler.init_noise_sigma\n\n outputs = (latents,)\n\n if return_noise:\n outputs += (noise,)\n\n if return_image_latents:\n outputs += (image_latents,)\n\n return outputs" }, { "identifier": "custom_prepare_mask_latents", "path": "relighting/pipeline_utils.py", "snippet": "def custom_prepare_mask_latents(\n self, mask, masked_image, batch_size, height, width, dtype, device, generator, do_classifier_free_guidance\n):\n # resize the mask to latents shape as we concatenate the mask to the latents\n # we do that before converting to dtype to avoid breaking in case we're using cpu_offload\n # and half precision\n mask = torch.nn.functional.interpolate(\n mask, size=(height // self.vae_scale_factor, width // self.vae_scale_factor),\n mode=\"bilinear\", align_corners=False #PURE: We add this to avoid sharp border of the ball\n )\n mask = mask.to(device=device, dtype=dtype)\n\n # duplicate mask and masked_image_latents for each generation per prompt, using mps friendly method\n if mask.shape[0] < batch_size:\n if not batch_size % mask.shape[0] == 0:\n raise ValueError(\n \"The passed mask and the required batch size don't match. Masks are supposed to be duplicated to\"\n f\" a total batch size of {batch_size}, but {mask.shape[0]} masks were passed. Make sure the number\"\n \" of masks that you pass is divisible by the total requested batch size.\"\n )\n mask = mask.repeat(batch_size // mask.shape[0], 1, 1, 1)\n\n mask = torch.cat([mask] * 2) if do_classifier_free_guidance else mask\n\n masked_image_latents = None\n if masked_image is not None:\n masked_image = masked_image.to(device=device, dtype=dtype)\n masked_image_latents = self._encode_vae_image(masked_image, generator=generator)\n if masked_image_latents.shape[0] < batch_size:\n if not batch_size % masked_image_latents.shape[0] == 0:\n raise ValueError(\n \"The passed images and the required batch size don't match. Images are supposed to be duplicated\"\n f\" to a total batch size of {batch_size}, but {masked_image_latents.shape[0]} images were passed.\"\n \" Make sure the number of images that you pass is divisible by the total requested batch size.\"\n )\n masked_image_latents = masked_image_latents.repeat(\n batch_size // masked_image_latents.shape[0], 1, 1, 1\n )\n\n masked_image_latents = (\n torch.cat([masked_image_latents] * 2) if do_classifier_free_guidance else masked_image_latents\n )\n\n # aligning device to prevent device errors when concating it with the latent model input\n masked_image_latents = masked_image_latents.to(device=device, dtype=dtype)\n\n return mask, masked_image_latents" }, { "identifier": "rescale_noise_cfg", "path": "relighting/pipeline_utils.py", "snippet": "def rescale_noise_cfg(noise_cfg, noise_pred_text, guidance_rescale=0.0):\n \"\"\"\n Rescale `noise_cfg` according to `guidance_rescale`. Based on findings of [Common Diffusion Noise Schedules and\n Sample Steps are Flawed](https://arxiv.org/pdf/2305.08891.pdf). See Section 3.4\n \"\"\"\n std_text = noise_pred_text.std(dim=list(range(1, noise_pred_text.ndim)), keepdim=True)\n std_cfg = noise_cfg.std(dim=list(range(1, noise_cfg.ndim)), keepdim=True)\n # rescale the results from guidance (fixes overexposure)\n noise_pred_rescaled = noise_cfg * (std_text / std_cfg)\n # mix with the original results from guidance by factor guidance_rescale to avoid \"plain looking\" images\n noise_cfg = guidance_rescale * noise_pred_rescaled + (1 - guidance_rescale) * noise_cfg\n return noise_cfg" } ]

[ { "identifier": "DynamicText", "path": "mactop/widgets/dynamic_text.py", "snippet": "class DynamicText(Static):\n value = reactive(None)\n\n DEFAULT_CSS = \"\"\"\n DynamicText {\n layout: horizontal;\n }\n \n \"\"\"\n\n def __init__(\n self,\n prefix_label,\n update_fn,\n value_render_fn,\n update_interval,\n warning_threshold=None,\n error_threshold=None,\n *args,\n **kwargs,\n ) -> None:\n super().__init__(*args, **kwargs)\n\n self.update_fn = update_fn\n self.value_render_fn = value_render_fn\n self.update_interval = update_interval\n self.prefix_label = prefix_label\n\n self.warning_threshold = warning_threshold\n self.error_threshold = error_threshold\n\n def on_mount(self) -> None:\n self.set_interval(self.update_interval, self.update_value)\n\n def update_value(self) -> None:\n result = self.update_fn()\n if result is not None:\n self.value = result\n\n def watch_value(self, value) -> None:\n if value is not None:\n try:\n number = self.query_one(\"Static.value\")\n except textual.css.query.NoMatches:\n logger.warning(\n \"Can not found DOM element in Static.value in DynamicText\"\n )\n return\n rendered_str = self.value_render_fn(value)\n number.update(rendered_str)\n\n def compose(self) -> ComposeResult:\n yield Label(f\"{self.prefix_label}\", classes=\"label\")\n yield Static(\"loading\", classes=\"value\")" }, { "identifier": "metrics", "path": "mactop/metrics_store.py", "snippet": "class ProcessorType(enum.Enum):\nclass Smc:\nclass PowerMetricsBattery:\nclass Netowrk:\nclass CPU:\nclass M1GPU:\nclass CPUCore:\nclass ProcessorPackage:\nclass M1CPUCluster:\nclass M1ProcessorPackage:\nclass ProcessorIntel:\nclass Disk:\nclass PowerMetrics:\nclass AdapterDetails:\nclass AppleSmartBattery:\nclass IORegMetrics:\nclass CPUTimesPercent:\nclass SwapMemory:\nclass VirtualMemory:\nclass LoadAvg:\nclass PsutilMetrics:\nclass Metrics:\n INTEL = \"intel\"\n M1 = \"M1\"\n def get_core(self, core_index):\n def get_psutilmetrics(self):\n def set_psutilmetrics(self, p: PsutilMetrics):\n def get_powermetrics(self):\n def set_powermetrics(self, metrics):\n def get_ioregmetrics(self):\n def set_ioregmetrics(self, metrics):" }, { "identifier": "BaseStatic", "path": "mactop/panels/_base.py", "snippet": "class BaseStatic(Static):\n def __init__(self, refresh_interval, *args, **kwargs):\n super().__init__(*args, **kwargs)\n self.refresh_interval = float(refresh_interval)" }, { "identifier": "const", "path": "mactop/const.py", "snippet": "COLOR_USER=\"green\"\nCOLOR_NICE=\"blue\"\nCOLOR_SYSTEM=\"#006400\"\nCOLOR_IDLE=\"#2F4F4F\"\nCOLOR_C_STATE=\"#008000\"\nCOLOR_P_STATE=\"#FF8C00\"" }, { "identifier": "LabeledSparkline", "path": "mactop/widgets/labeled_sparkline.py", "snippet": "class LabeledSparkline(Static):\n value = reactive(None)\n\n DEFAULT_CSS = \"\"\"\n LabeledSparkline {\n layout: horizontal;\n height: 1;\n }\n LabeledSparkline > Sparkline {\n width: 1fr;\n }\n\n LabeledSparkline .sparkline--max-color {\n color: $warning;\n }\n LabeledSparkline .sparkline--min-color {\n color: $warning 50%;\n }\n\n ReversedSparkline {\n text-style: reverse;\n }\n \"\"\"\n\n def __init__(\n self,\n prefix_label,\n update_fn: Callable[[], List[float]],\n value_render_fn,\n update_interval=1.0,\n sparkline_reverse=False,\n *args,\n **kwargs,\n ) -> None:\n super().__init__(*args, **kwargs)\n\n self.update_fn = update_fn\n self.value_render_fn = value_render_fn\n self.update_interval = update_interval\n self.prefix_label = prefix_label\n self.sparkline_reverse = sparkline_reverse\n\n def on_mount(self) -> None:\n self.set_interval(self.update_interval, self.update_value)\n\n def update_value(self) -> None:\n result = self.update_fn()\n if result is not None:\n self.value = copy.copy(result)\n\n def watch_value(self, value) -> None:\n if not value:\n return\n last = value[-1]\n\n try:\n number_widget = self.query_one(\"Static.sparklineValue\")\n number_str = self.value_render_fn(last)\n number_widget.styles.width = len(number_str)\n number_widget.update(number_str)\n\n sparkline = self.query_one(\".sparkline-chart\")\n except textual.css.query.NoMatches:\n logger.warning(\n \"Can not found DOM element in Sparkline\"\n )\n return\n sparkline.data = value\n\n def compose(self) -> ComposeResult:\n yield Label(f\"{self.prefix_label} \", classes=\"sparklineLabel\")\n if self.sparkline_reverse:\n yield ReversedSparkline(self.value, classes=\"sparkline-chart\")\n else:\n Sparkline.DEFAULT_CSS = \"\"\n yield Sparkline(self.value, classes=\"sparkline-chart\")\n yield Static(\" \", classes=\"sparklineValue\")" }, { "identifier": "LabeledColorBar", "path": "mactop/widgets/labeled_colorbar.py", "snippet": "class LabeledColorBar(Static):\n percentages = reactive(None)\n\n DEFAULT_CSS = \"\"\"\n LabeledColorBar {\n layout: horizontal;\n }\n LabeledColorBar > ColorBar {\n width: 1fr;\n }\n \"\"\"\n\n def __init__(\n self,\n prefix_label,\n color_choices,\n update_interval,\n percentages_update_fn: Callable[[], List[float]],\n value_render_fn: Callable[[List[float]], str],\n *args,\n **kwargs,\n ) -> None:\n super().__init__(*args, **kwargs)\n\n self.percentages_update_fn = percentages_update_fn\n self.color_choices = color_choices\n self.update_interval = update_interval\n self.prefix_label = prefix_label\n self.value_render_fn = value_render_fn\n\n def on_mount(self) -> None:\n self.set_interval(self.update_interval, self.update_percentages)\n\n def update_percentages(self) -> None:\n result = self.percentages_update_fn()\n if result is not None:\n self.percentages = copy.copy(result)\n\n def watch_percentages(self, percentages) -> None:\n if not percentages:\n return\n\n try:\n number_widget = self.query_one(\".colorbar-value\")\n except textual.css.query.NoMatches:\n logger.warning(\n \"Can not found DOM element in .colorbar-value in LabeledColorBar\"\n )\n return\n number_str = self.value_render_fn(percentages)\n number_widget.styles.width = len(number_str)\n number_widget.update(number_str)\n\n colorbar = self.query_one(\"ColorBar\")\n colorbar.percentages = percentages\n\n def compose(self) -> ComposeResult:\n yield Label(f\"{self.prefix_label}\", classes=\"colorbar-label\")\n yield ColorBar(self.color_choices)\n yield Static(\" \", classes=\"colorbar-value\")" } ]

[ { "identifier": "load_pose", "path": "lib/datasets/shapenet_srn.py", "snippet": "def load_pose(path):\n pose = np.loadtxt(path, dtype=np.float32, delimiter=' ').reshape(4, 4)\n return torch.from_numpy(pose)" }, { "identifier": "load_intrinsics", "path": "lib/datasets/shapenet_srn.py", "snippet": "def load_intrinsics(path):\n with open(path, 'r') as file:\n f, cx, cy, _ = map(float, file.readline().split())\n grid_barycenter = list(map(float, file.readline().split()))\n scale = float(file.readline())\n height, width = map(int, file.readline().split())\n fx = fy = f\n return fx, fy, cx, cy, height, width" } ]

[ { "identifier": "AdaptiveLayerNorm1D", "path": "hamer/models/components/t_cond_mlp.py", "snippet": "class AdaptiveLayerNorm1D(torch.nn.Module):\n def __init__(self, data_dim: int, norm_cond_dim: int):\n super().__init__()\n if data_dim <= 0:\n raise ValueError(f\"data_dim must be positive, but got {data_dim}\")\n if norm_cond_dim <= 0:\n raise ValueError(f\"norm_cond_dim must be positive, but got {norm_cond_dim}\")\n self.norm = torch.nn.LayerNorm(\n data_dim\n ) # TODO: Check if elementwise_affine=True is correct\n self.linear = torch.nn.Linear(norm_cond_dim, 2 * data_dim)\n torch.nn.init.zeros_(self.linear.weight)\n torch.nn.init.zeros_(self.linear.bias)\n\n def forward(self, x: torch.Tensor, t: torch.Tensor) -> torch.Tensor:\n # x: (batch, ..., data_dim)\n # t: (batch, norm_cond_dim)\n # return: (batch, data_dim)\n x = self.norm(x)\n alpha, beta = self.linear(t).chunk(2, dim=-1)\n\n # Add singleton dimensions to alpha and beta\n if x.dim() > 2:\n alpha = alpha.view(alpha.shape[0], *([1] * (x.dim() - 2)), alpha.shape[1])\n beta = beta.view(beta.shape[0], *([1] * (x.dim() - 2)), beta.shape[1])\n\n return x * (1 + alpha) + beta" }, { "identifier": "FrequencyEmbedder", "path": "hamer/models/components/t_cond_mlp.py", "snippet": "class FrequencyEmbedder(torch.nn.Module):\n def __init__(self, num_frequencies, max_freq_log2):\n super().__init__()\n frequencies = 2 ** torch.linspace(0, max_freq_log2, steps=num_frequencies)\n self.register_buffer(\"frequencies\", frequencies)\n\n def forward(self, x):\n # x should be of size (N,) or (N, D)\n N = x.size(0)\n if x.dim() == 1: # (N,)\n x = x.unsqueeze(1) # (N, D) where D=1\n x_unsqueezed = x.unsqueeze(-1) # (N, D, 1)\n scaled = self.frequencies.view(1, 1, -1) * x_unsqueezed # (N, D, num_frequencies)\n s = torch.sin(scaled)\n c = torch.cos(scaled)\n embedded = torch.cat([s, c, x_unsqueezed], dim=-1).view(\n N, -1\n ) # (N, D * 2 * num_frequencies + D)\n return embedded" }, { "identifier": "normalization_layer", "path": "hamer/models/components/t_cond_mlp.py", "snippet": "def normalization_layer(norm: Optional[str], dim: int, norm_cond_dim: int = -1):\n if norm == \"batch\":\n return torch.nn.BatchNorm1d(dim)\n elif norm == \"layer\":\n return torch.nn.LayerNorm(dim)\n elif norm == \"ada\":\n assert norm_cond_dim > 0, f\"norm_cond_dim must be positive, got {norm_cond_dim}\"\n return AdaptiveLayerNorm1D(dim, norm_cond_dim)\n elif norm is None:\n return torch.nn.Identity()\n else:\n raise ValueError(f\"Unknown norm: {norm}\")" } ]

[ { "identifier": "extract_high_level_plan_and_actions", "path": "driver/brain.py", "snippet": "def extract_high_level_plan_and_actions(input: str):\n pattern = r\"^A\\. High.?level([\\s\\S]*?)^B\\.\\s*([\\s\\S]*)\"\n\n match = re.search(pattern, input, re.DOTALL | re.MULTILINE | re.IGNORECASE)\n\n if match:\n between_tokens = match.group(1).strip()\n after_token_b = match.group(2).strip()\n\n return str(between_tokens), str(after_token_b)\n else:\n return None, None" }, { "identifier": "extract_structured_actions", "path": "driver/brain.py", "snippet": "def extract_structured_actions(input: str):\n actions = heuristics_extract_structured_actions(input)\n if not actions:\n actions = llm_structured_actions(input)\n return actions" }, { "identifier": "plan_next_step_actions", "path": "driver/brain.py", "snippet": "def plan_next_step_actions(context: Context, image_path: str):\n print_action(\"Looking at the screen to plan next steps\")\n print(\"Analyzing...\")\n\n initial_user_prompt = f\"\"\"\\\n Task: {context['task']}\n\n Here is a screenshot of the screen, tagged with labels like A1, A2, A3 on each interactive item, please do two things:\n\n A. High level list of steps to follow, using a numbered list in english text\n\n B. A list of actions to execute, being one of [CLICK A1] to click the A1 button for example, \\\n [TYPE \"message\"] to type \"message\", [PRESS ENTER] to \\\n press keys ENTER or shortcuts like CMD+F if needed, and [REFRESH] to end the list and get a new screenshot of the screen. \\\n Those are the ONLY options you have, work with that. If you need to switch apps,\n use [PRESS CMD+SPACE] to open the spotlight and then [REFRESH]. \\\n If you want to click or type on an element that is not on the screen, issue a [REFRESH] first. \\\n \"\"\"\n\n next_step_user_prompt = f\"\"\"\\\n Alright, I have executed the previous actions, let me share you the updated screenshot, so you can plan the next actions.\n Describe what you are seeing, and describe where it might have gone wrong, because usually the screen changes and we have to course correct.\n As a reminder my goal is: {context['task']}.\n\n Please create a list with the next actions to take if any (options are [CLICK <LABEL>], [TYPE \"<TEXT>\"], [SHORTCUT <shortcut>] or [REFRESH]).\n Pay extra attention to the labels on the screen, you need to name them correctly, and a place you want to click is not labeled, choose another one.\n \"\"\"\n\n user_prompt = (\n initial_user_prompt if len(context[\"history\"]) == 0 else next_step_user_prompt\n )\n\n user_message: List[ChatCompletionMessageParam] = [\n {\n \"role\": \"user\",\n \"content\": [\n {\n \"type\": \"text\",\n \"text\": user_prompt,\n },\n {\n \"type\": \"image_url\",\n \"image_url\": {\n \"url\": image_to_base64(image_path),\n \"detail\": \"high\",\n },\n },\n ],\n }\n ]\n\n history = context[\"history\"]\n\n system_message: List[ChatCompletionMessageParam] = [\n {\n \"role\": \"system\",\n \"content\": \"\"\"\\\n You are an AI agent with capacity to see the user's screen, click buttons and type text.\n The user will ask you to do things, you will see the user screen, then you will first think\n in high level what are the steps you will need to follow to carry the task. Then, you will\n be given annotated screenshots with codes mapping buttons and texts on the screen, which you\n can choose to click and proceed, type in an input field, and get a refreshed update of the\n screen to continue until the task is completed. You are always very short and concise in your writing.\"\"\",\n },\n ]\n\n model = \"gpt-4-vision-preview\"\n messages = system_message + history + user_message\n\n response = client.chat.completions.create(\n model=model,\n messages=messages,\n stream=True,\n max_tokens=600,\n )\n\n content = \"\"\n for chunk in response:\n if delta := chunk.choices[0].delta.content:\n print(delta, end=\"\", flush=True)\n content += delta\n\n context[\"history\"].append(\n {\n \"role\": \"user\",\n \"content\": user_prompt,\n }\n )\n context[\"history\"].append(\n {\n \"role\": \"assistant\",\n \"content\": content,\n }\n )\n\n log_cost(\n model=model,\n messages=system_message + history,\n completion=content,\n image={\n \"text\": user_prompt,\n \"path\": image_path,\n \"detail\": \"high\",\n },\n )\n\n return content" }, { "identifier": "print_action", "path": "driver/logger.py", "snippet": "def print_action(str: str):\n print(Fore.YELLOW + \"\\n\\n> \" + str + \"\\n\" + Style.RESET_ALL)" }, { "identifier": "annotate_image", "path": "driver/annotator.py", "snippet": "def annotate_image(input_image_path, debug: DebugConfig):\n ocr_result = ocr_text_detection(input_image_path, debug)\n\n components = detect_components(\n input_image_path,\n ocr_result,\n showOCR=debug[\"ocr\"],\n showUIED=debug[\"uied\"],\n )\n\n original_image = Image.open(input_image_path)\n size = {\"width\": original_image.width, \"height\": original_image.height}\n img_multiplier_factor: ImgMultiplierFactor = {\n \"height\": components[\"img_shape\"][0] / size[\"height\"],\n \"width\": components[\"img_shape\"][1] / size[\"width\"],\n }\n\n label_counter = 1\n label_prefix = \"A\"\n drawn_positions = []\n label_map: LabelMap = {}\n\n label_width = 48 if is_retina_display() else 24\n label_height = 24 if is_retina_display() else 12\n\n # Most likely the biggest components are the most important ones to be clicked on the screen,\n # and seems like GPT-V will be biased anyway towards choosing A1, A2, etc the early labels,\n # so we try to play into that and label from the biggest to the smallest components\n sorted_components = sorted(\n components[\"compos\"],\n key=lambda x: (x.row_max - x.row_min) * (x.col_max - x.col_min),\n reverse=True\n )\n\n for component in sorted_components:\n if component.text_content and len(component.text_content) < 2:\n continue\n\n component_position = {\n \"x\": round(component.col_min / img_multiplier_factor[\"width\"]),\n \"y\": round(component.row_min / img_multiplier_factor[\"height\"]),\n \"x2\": round(component.col_max / img_multiplier_factor[\"width\"]),\n \"y2\": round(component.row_max / img_multiplier_factor[\"height\"]),\n }\n component_width = component_position[\"x2\"] - component_position[\"x\"]\n component_height = component_position[\"y2\"] - component_position[\"y\"]\n\n if component_height < label_height:\n continue\n\n label_position = (\n round(component_position[\"x\"] - label_width / 2),\n round(component_position[\"y\"] - label_height / 2),\n )\n\n # Draw label in the center of the component for big components\n big_component = 200 if is_retina_display() else 100\n if component_width > big_component and component_height > big_component:\n label_position = (\n round(component_position[\"x\"] + component_width / 2 - label_width),\n round(component_position[\"y\"] + component_height / 2 - label_height),\n )\n\n too_close = any(\n abs(label_position[0] - pos[0]) < label_width\n and abs(label_position[1] - pos[1]) < label_height * 2\n for pos in drawn_positions\n )\n if too_close:\n continue\n\n if label_counter > 9:\n label_counter = 1\n next_char = chr(ord(label_prefix[-1]) + 1)\n if next_char == \"I\":\n next_char = \"J\" # Skip 'I' to avoid confusion with 'l'\n if label_prefix[-1] == \"Z\":\n label_prefix += \"A\"\n else:\n label_prefix = label_prefix[:-1] + next_char\n label = f\"{label_prefix}{label_counter}\"\n draw_square(\n original_image,\n label_position,\n label,\n width=label_width,\n height=label_height,\n )\n drawn_positions.append(label_position)\n label_map[label] = {\n \"text\": component.text_content or \"\",\n \"position\": (\n component_position[\"x\"],\n component_position[\"y\"],\n ),\n \"size\": (\n component_width,\n component_height,\n ),\n }\n label_counter += 1\n\n os.makedirs(\"./output/annotated\", exist_ok=True)\n output_image_path = f\"./output/annotated/{os.path.basename(input_image_path)}\"\n original_image.save(output_image_path)\n\n print(f\"{len(label_map.keys())} elements found on the screen\", end=\"\")\n if debug[\"annotations\"]:\n show_image(\"Annotated\", cv2.imread(output_image_path))\n\n return label_map, output_image_path, img_multiplier_factor" }, { "identifier": "Action", "path": "driver/types.py", "snippet": "class Click(TypedDict):\nclass Type(TypedDict):\nclass Press(TypedDict):\nclass Refresh(TypedDict):\nclass LabelMapItem(TypedDict):\nclass ImgMultiplierFactor(TypedDict):\nclass DebugConfig(TypedDict):\nclass Context(TypedDict):\nclass Vertex:\nclass BoundingPoly:\nclass TextAnnotation:\nclass AnnotatedImage:" }, { "identifier": "is_retina_display", "path": "driver/utils.py", "snippet": "def is_retina_display():\n return is_retina" } ]

[ { "identifier": "Component", "path": "appbuilder/core/component.py", "snippet": "class ComponentArguments(BaseModel):\nclass Component:\n def extract_values_to_dict(self):\n def __init__(self,\n meta: Optional[ComponentArguments] = ComponentArguments(),\n secret_key: Optional[str] = None,\n gateway: str = \"\"\n ):\n def __call__(self, *inputs, **kwargs):\n def run(self, *inputs, **kwargs):\n def batch(self, *args, **kwargs) -> List[Message]:\n async def arun(self, *args, **kwargs) -> Optional[Message]:\n async def abatch(self, *args, **kwargs) -> List[Message]:\n def _trace(self, **data) -> None:\n def _debug(self, **data) -> None:" }, { "identifier": "Embedding", "path": "appbuilder/core/components/embeddings/component.py", "snippet": "class Embedding(EmbeddingBaseComponent):\n \"\"\"\n Embedding\n\n Embedding-V1是基于百度文心大模型技术的文本表示模型，将文本转化为用数值表示的向量形式，用于文本检索、信息推荐、知识挖掘等场景。\n\n Examples:\n\n .. code-block:: python\n\n import appbuilder\n from appbuilder import Message\n\n os.environ[\"APPBUILDER_TOKEN\"] = '...'\n\n embedding = appbuilder.Embedding()\n\n embedding_single = embedding(Message(\"hello world!\"))\n\n embedding_batch = embedding.batch(Message([\"hello\", \"world\"]))\n \"\"\"\n\n name: str = \"embedding\"\n version: str = \"v1\"\n\n meta = EmbeddingArgs\n accepted_models = [\"Embedding-V1\"]\n\n base_urls = {\n 'Embedding-V1' : \"/v1/bce/wenxinworkshop/ai_custom/v1/embeddings/embedding-v1\"\n }\n\n def __init__(self, model=\"Embedding-V1\"):\n \"\"\"Embedding\"\"\"\n\n if model not in self.accepted_models:\n raise ModelNotSupportedException(f\"Model {model} not supported, only support {self.accepted_models}\")\n\n if model in self.base_urls:\n self.base_url = self.base_urls[model]\n else:\n raise ModelNotSupportedException(f\"Model {model} is not yet supported, only support {self.base_urls.keys()}\")\n\n super().__init__(self.meta)\n\n def _check_response_json(self, data: dict):\n \"\"\"\n check_response_json for embedding\n \"\"\"\n\n self.http_client.check_response_json(data)\n if \"error_code\" in data and \"error_msg\" in data:\n raise AppBuilderServerException(\n service_err_code=data['error_code'],\n service_err_message=data['error_msg'],\n )\n\n def _request(self, payload: dict) -> dict:\n \"\"\"\n request to gateway\n \"\"\"\n headers = self.http_client.auth_header()\n headers[\"Content-Type\"] = \"application/json\"\n resp = self.http_client.session.post(\n url=self.http_client.service_url(self.base_url),\n headers=headers,\n json=payload,\n )\n self.http_client.check_response_header(resp)\n self._check_response_json(resp.json())\n\n return resp.json()\n\n def _batchify(self, texts: List[str], batch_size: int = 16) -> List[List[str]]:\n \"\"\"\n batchify input text list\n \"\"\"\n\n if batch_size > 16:\n raise ValueError(f\"The max Embedding batch_size is 16, but got {batch_size}\")\n\n return [\n texts[i : i + batch_size] for i in range(0, len(texts), batch_size)\n ]\n\n def _batch(self, texts: List[str]) -> Message[List[List[float]]]:\n \"\"\"\n batch run implement\n \"\"\"\n\n batches = self._batchify(texts)\n results = []\n for batch in batches:\n result = self._request({\"input\": batch})\n results.extend(result['data'])\n results = Message([result['embedding'] for result in results])\n\n return results\n\n def run(self, text: Union[Message[str], str]) -> Message[List[float]]:\n \"\"\"\n run\n \"\"\"\n \n _text = text if isinstance(text, str) else text.content\n\n return Message(self._batch([_text]).content[0])\n\n def batch(self, texts: Union[Message[List[str]], List[str]]) -> Message[List[List[float]]]:\n \"\"\"\n batch run\n \"\"\"\n\n _texts = texts if isinstance(texts, list) else texts.content\n\n return self._batch(_texts)" }, { "identifier": "GATEWAY_URL", "path": "appbuilder/core/constants.py", "snippet": "GATEWAY_URL = \"https://appbuilder.baidu.com\"" }, { "identifier": "logger", "path": "appbuilder/utils/logger_util.py", "snippet": "LOGGING_CONFIG = {\n 'version': 1,\n 'disable_existing_loggers': False,\n 'formatters': {\n 'standard': {\n 'format': '[%(asctime)s.%(msecs)03d] %(filename)s [line:%(lineno)d] %(levelname)s [%(logid)s] %(message)s',\n },\n },\n 'handlers': {\n 'console': {\n 'level': 'INFO',\n 'class': 'logging.StreamHandler',\n 'formatter': 'standard',\n 'stream': 'ext://sys.stdout', # Use standard output\n },\n },\n 'loggers': {\n 'appbuilder': {\n 'handlers': ['console'],\n 'level': 'INFO',\n 'propagate': True,\n },\n }\n}\nclass LoggerWithLoggerId(logging.LoggerAdapter):\n def __init__(self, logger, extra, loglevel):\n def set_auto_logid(self):\n def set_logid(self, logid):\n def get_logid(self):\n def level(self):\n def process(self, msg, kwargs):\ndef _setup_logging():" } ]

[ { "identifier": "UCMCTrack", "path": "tracker/ucmc.py", "snippet": "class UCMCTrack(object):\n def __init__(self,a1,a2,wx, wy,vmax, max_age, fps, dataset, high_score, use_cmc,detector = None):\n self.wx = wx\n self.wy = wy\n self.vmax = vmax\n self.dataset = dataset\n self.high_score = high_score\n self.max_age = max_age\n self.a1 = a1\n self.a2 = a2\n self.dt = 1.0/fps\n\n self.use_cmc = use_cmc\n\n self.trackers = []\n self.confirmed_idx = []\n self.coasted_idx = []\n self.tentative_idx = []\n\n self.detector = detector\n\n\n def update(self, dets,frame_id):\n \n self.data_association(dets,frame_id)\n \n self.associate_tentative(dets)\n \n self.initial_tentative(dets)\n \n self.delete_old_trackers()\n \n self.update_status(dets)\n \n def data_association(self, dets,frame_id):\n # Separate detections into high score and low score\n detidx_high = []\n detidx_low = []\n for i in range(len(dets)):\n if dets[i].conf >= self.high_score:\n detidx_high.append(i)\n else:\n detidx_low.append(i)\n\n # Predcit new locations of tracks\n for track in self.trackers:\n track.predict()\n if self.use_cmc:\n x,y = self.detector.cmc(track.kf.x[0,0],track.kf.x[2,0],track.w,track.h,frame_id)\n track.kf.x[0,0] = x\n track.kf.x[2,0] = y\n \n trackidx_remain = []\n self.detidx_remain = []\n\n # Associate high score detections with tracks\n trackidx = self.confirmed_idx + self.coasted_idx\n num_det = len(detidx_high)\n num_trk = len(trackidx)\n\n for trk in self.trackers:\n trk.detidx = -1\n\n if num_det*num_trk > 0:\n cost_matrix = np.zeros((num_det, num_trk))\n for i in range(num_det):\n det_idx = detidx_high[i]\n for j in range(num_trk):\n trk_idx = trackidx[j]\n cost_matrix[i,j] = self.trackers[trk_idx].distance(dets[det_idx].y, dets[det_idx].R)\n \n matched_indices,unmatched_a,unmatched_b = linear_assignment(cost_matrix, self.a1)\n \n for i in unmatched_a:\n self.detidx_remain.append(detidx_high[i])\n for i in unmatched_b:\n trackidx_remain.append(trackidx[i])\n \n for i,j in matched_indices:\n det_idx = detidx_high[i]\n trk_idx = trackidx[j]\n self.trackers[trk_idx].update(dets[det_idx].y, dets[det_idx].R)\n self.trackers[trk_idx].death_count = 0\n self.trackers[trk_idx].detidx = det_idx\n self.trackers[trk_idx].status = TrackStatus.Confirmed\n dets[det_idx].track_id = self.trackers[trk_idx].id\n\n else:\n self.detidx_remain = detidx_high\n trackidx_remain = trackidx\n\n \n # Associate low score detections with remain tracks\n num_det = len(detidx_low)\n num_trk = len(trackidx_remain)\n if num_det*num_trk > 0:\n cost_matrix = np.zeros((num_det, num_trk))\n for i in range(num_det):\n det_idx = detidx_low[i]\n for j in range(num_trk):\n trk_idx = trackidx_remain[j]\n cost_matrix[i,j] = self.trackers[trk_idx].distance(dets[det_idx].y, dets[det_idx].R)\n \n matched_indices,unmatched_a,unmatched_b = linear_assignment(cost_matrix,self.a2)\n \n\n for i in unmatched_b:\n trk_idx = trackidx_remain[i]\n self.trackers[trk_idx].status = TrackStatus.Coasted\n # self.trackers[trk_idx].death_count += 1\n self.trackers[trk_idx].detidx = -1\n\n for i,j in matched_indices:\n det_idx = detidx_low[i]\n trk_idx = trackidx_remain[j]\n self.trackers[trk_idx].update(dets[det_idx].y, dets[det_idx].R)\n self.trackers[trk_idx].death_count = 0\n self.trackers[trk_idx].detidx = det_idx\n self.trackers[trk_idx].status = TrackStatus.Confirmed\n dets[det_idx].track_id = self.trackers[trk_idx].id\n\n\n def associate_tentative(self, dets):\n num_det = len(self.detidx_remain)\n num_trk = len(self.tentative_idx)\n\n cost_matrix = np.zeros((num_det, num_trk))\n for i in range(num_det):\n det_idx = self.detidx_remain[i]\n for j in range(num_trk):\n trk_idx = self.tentative_idx[j]\n cost_matrix[i,j] = self.trackers[trk_idx].distance(dets[det_idx].y, dets[det_idx].R)\n \n matched_indices,unmatched_a,unmatched_b = linear_assignment(cost_matrix,self.a1)\n\n for i,j in matched_indices:\n det_idx = self.detidx_remain[i]\n trk_idx = self.tentative_idx[j]\n self.trackers[trk_idx].update(dets[det_idx].y, dets[det_idx].R)\n self.trackers[trk_idx].death_count = 0\n self.trackers[trk_idx].birth_count += 1\n self.trackers[trk_idx].detidx = det_idx\n dets[det_idx].track_id = self.trackers[trk_idx].id\n if self.trackers[trk_idx].birth_count >= 2:\n self.trackers[trk_idx].birth_count = 0\n self.trackers[trk_idx].status = TrackStatus.Confirmed\n\n for i in unmatched_b:\n trk_idx = self.tentative_idx[i]\n # self.trackers[trk_idx].death_count += 1\n self.trackers[trk_idx].detidx = -1\n\n \n unmatched_detidx = []\n for i in unmatched_a:\n unmatched_detidx.append(self.detidx_remain[i])\n self.detidx_remain = unmatched_detidx\n\n \n \n def initial_tentative(self,dets):\n for i in self.detidx_remain: \n self.trackers.append(KalmanTracker(dets[i].y,dets[i].R,self.wx,self.wy,self.vmax, dets[i].bb_width,dets[i].bb_height,self.dt))\n self.trackers[-1].status = TrackStatus.Tentative\n self.trackers[-1].detidx = i\n self.detidx_remain = []\n\n def delete_old_trackers(self):\n i = len(self.trackers)\n for trk in reversed(self.trackers):\n trk.death_count += 1\n i -= 1 \n if ( trk.status == TrackStatus.Coasted and trk.death_count >= self.max_age) or ( trk.status == TrackStatus.Tentative and trk.death_count >= 2):\n self.trackers.pop(i)\n\n def update_status(self,dets):\n self.confirmed_idx = []\n self.coasted_idx = []\n self.tentative_idx = []\n for i in range(len(self.trackers)):\n\n detidx = self.trackers[i].detidx\n if detidx >= 0 and detidx < len(dets):\n self.trackers[i].h = dets[detidx].bb_height\n self.trackers[i].w = dets[detidx].bb_width\n\n if self.trackers[i].status == TrackStatus.Confirmed:\n self.confirmed_idx.append(i)\n elif self.trackers[i].status == TrackStatus.Coasted:\n self.coasted_idx.append(i)\n elif self.trackers[i].status == TrackStatus.Tentative:\n self.tentative_idx.append(i)" }, { "identifier": "Mapper", "path": "detector/mapper.py", "snippet": "class Mapper(object):\n def __init__(self, campara_file,dataset= \"kitti\"):\n self.A = np.zeros((3, 3))\n if dataset == \"kitti\":\n self.KiKo, self.is_ok = readKittiCalib(campara_file)\n z0 = -1.73\n else:\n self.KiKo, self.is_ok = readCamParaFile(campara_file)\n z0 = 0\n\n self.A[:, :2] = self.KiKo[:, :2]\n self.A[:, 2] = z0 * self.KiKo[:, 2] + self.KiKo[:, 3]\n self.InvA = np.linalg.inv(self.A)\n\n def uv2xy(self, uv, sigma_uv):\n if self.is_ok == False:\n return None, None\n\n uv1 = np.zeros((3, 1))\n uv1[:2,:] = uv\n uv1[2,:] = 1\n b = np.dot(self.InvA, uv1)\n gamma = 1 / b[2,:]\n C = gamma * self.InvA[:2, :2] - (gamma**2) * b[:2,:] * self.InvA[2, :2]\n xy = b[:2,:] * gamma\n sigma_xy = np.dot(np.dot(C, sigma_uv), C.T)\n return xy, sigma_xy\n \n def xy2uv(self,x,y):\n if self.is_ok == False:\n return None, None\n xy1 = np.zeros((3, 1))\n xy1[0,0] = x\n xy1[1,0] = y\n xy1[2,0] = 1\n uv1 = np.dot(self.A, xy1)\n return uv1[0,0]/uv1[2,0],uv1[1,0]/uv1[2,0]\n \n def mapto(self,box):\n uv = np.array([[box[0]+box[2]/2], [box[1]+box[3]]])\n u_err,v_err = getUVError(box)\n sigma_uv = np.identity(2)\n sigma_uv[0,0] = u_err*u_err\n sigma_uv[1,1] = v_err*v_err\n y,R = self.uv2xy(uv, sigma_uv)\n return y,R" } ]

[ { "identifier": "inverse_sigmoid", "path": "utils/general_utils.py", "snippet": "def inverse_sigmoid(x):\n return torch.log(x / (1 - x))" }, { "identifier": "get_expon_lr_func", "path": "utils/general_utils.py", "snippet": "def get_expon_lr_func(\n lr_init, lr_final, lr_delay_steps=0, lr_delay_mult=1.0, max_steps=1000000\n):\n \"\"\"\n Copied from Plenoxels\n\n Continuous learning rate decay function. Adapted from JaxNeRF\n The returned rate is lr_init when step=0 and lr_final when step=max_steps, and\n is log-linearly interpolated elsewhere (equivalent to exponential decay).\n If lr_delay_steps>0 then the learning rate will be scaled by some smooth\n function of lr_delay_mult, such that the initial learning rate is\n lr_init*lr_delay_mult at the beginning of optimization but will be eased back\n to the normal learning rate when steps>lr_delay_steps.\n :param conf: config subtree 'lr' or similar\n :param max_steps: int, the number of steps during optimization.\n :return HoF which takes step as input\n \"\"\"\n\n def helper(step):\n if step < 0 or (lr_init == 0.0 and lr_final == 0.0):\n # Disable this parameter\n return 0.0\n if lr_delay_steps > 0:\n # A kind of reverse cosine decay.\n delay_rate = lr_delay_mult + (1 - lr_delay_mult) * np.sin(\n 0.5 * np.pi * np.clip(step / lr_delay_steps, 0, 1)\n )\n else:\n delay_rate = 1.0\n t = np.clip(step / max_steps, 0, 1)\n log_lerp = np.exp(np.log(lr_init) * (1 - t) + np.log(lr_final) * t)\n return delay_rate * log_lerp\n\n return helper" }, { "identifier": "build_rotation", "path": "utils/general_utils.py", "snippet": "def build_rotation(r):\n norm = torch.sqrt(r[:, 0] * r[:, 0] + r[:, 1] * r[:, 1] + r[:, 2] * r[:, 2] + r[:, 3] * r[:, 3])\n\n q = r / norm[:, None]\n\n R = torch.zeros((q.size(0), 3, 3), device='cuda')\n\n r = q[:, 0]\n x = q[:, 1]\n y = q[:, 2]\n z = q[:, 3]\n\n R[:, 0, 0] = 1 - 2 * (y * y + z * z)\n R[:, 0, 1] = 2 * (x * y - r * z)\n R[:, 0, 2] = 2 * (x * z + r * y)\n R[:, 1, 0] = 2 * (x * y + r * z)\n R[:, 1, 1] = 1 - 2 * (x * x + z * z)\n R[:, 1, 2] = 2 * (y * z - r * x)\n R[:, 2, 0] = 2 * (x * z - r * y)\n R[:, 2, 1] = 2 * (y * z + r * x)\n R[:, 2, 2] = 1 - 2 * (x * x + y * y)\n return R" }, { "identifier": "get_linear_noise_func", "path": "utils/general_utils.py", "snippet": "def get_linear_noise_func(\n lr_init, lr_final, lr_delay_steps=0, lr_delay_mult=1.0, max_steps=1000000\n):\n \"\"\"\n Copied from Plenoxels\n\n Continuous learning rate decay function. Adapted from JaxNeRF\n The returned rate is lr_init when step=0 and lr_final when step=max_steps, and\n is log-linearly interpolated elsewhere (equivalent to exponential decay).\n If lr_delay_steps>0 then the learning rate will be scaled by some smooth\n function of lr_delay_mult, such that the initial learning rate is\n lr_init*lr_delay_mult at the beginning of optimization but will be eased back\n to the normal learning rate when steps>lr_delay_steps.\n :param conf: config subtree 'lr' or similar\n :param max_steps: int, the number of steps during optimization.\n :return HoF which takes step as input\n \"\"\"\n\n def helper(step):\n if step < 0 or (lr_init == 0.0 and lr_final == 0.0):\n # Disable this parameter\n return 0.0\n if lr_delay_steps > 0:\n # A kind of reverse cosine decay.\n delay_rate = lr_delay_mult + (1 - lr_delay_mult) * np.sin(\n 0.5 * np.pi * np.clip(step / lr_delay_steps, 0, 1)\n )\n else:\n delay_rate = 1.0\n t = np.clip(step / max_steps, 0, 1)\n log_lerp = lr_init * (1 - t) + lr_final * t\n return delay_rate * log_lerp\n\n return helper" }, { "identifier": "mkdir_p", "path": "utils/system_utils.py", "snippet": "def mkdir_p(folder_path):\n # Creates a directory. equivalent to using mkdir -p on the command line\n try:\n makedirs(folder_path)\n except OSError as exc: # Python >2.5\n if exc.errno == EEXIST and path.isdir(folder_path):\n pass\n else:\n raise" }, { "identifier": "RGB2SH", "path": "utils/sh_utils.py", "snippet": "def RGB2SH(rgb):\n return (rgb - 0.5) / C0" }, { "identifier": "BasicPointCloud", "path": "utils/graphics_utils.py", "snippet": "class BasicPointCloud(NamedTuple):\n points: np.array\n colors: np.array\n normals: np.array" }, { "identifier": "strip_symmetric", "path": "utils/general_utils.py", "snippet": "def strip_symmetric(sym):\n return strip_lowerdiag(sym)" }, { "identifier": "build_scaling_rotation", "path": "utils/general_utils.py", "snippet": "def build_scaling_rotation(s, r):\n L = torch.zeros((s.shape[0], 3, 3), dtype=torch.float, device=\"cuda\")\n R = build_rotation(r)\n\n L[:, 0, 0] = s[:, 0]\n L[:, 1, 1] = s[:, 1]\n L[:, 2, 2] = s[:, 2]\n\n L = R @ L\n return L" }, { "identifier": "flip_align_view", "path": "utils/general_utils.py", "snippet": "def flip_align_view(normal, viewdir):\n # normal: (N, 3), viewdir: (N, 3)\n dotprod = torch.sum(\n normal * -viewdir, dim=-1, keepdims=True) # (N, 1)\n non_flip = dotprod >= 0 # (N, 1)\n normal_flipped = normal * torch.where(non_flip, 1, -1) # (N, 3)\n return normal_flipped, non_flip" }, { "identifier": "get_minimum_axis", "path": "utils/general_utils.py", "snippet": "def get_minimum_axis(scales, rotations):\n sorted_idx = torch.argsort(scales, descending=False, dim=-1)\n R = build_rotation(rotations)\n R_sorted = torch.gather(R, dim=1, index=sorted_idx[:, :, None].repeat(1, 1, 3)).squeeze()\n x_axis = R_sorted[:, 0, :] # normalized by defaut\n\n return x_axis" } ]

[ { "identifier": "Attention", "path": "diffsynth/models/attention.py", "snippet": "class Attention(torch.nn.Module):\n\n def __init__(self, q_dim, num_heads, head_dim, kv_dim=None, bias_q=False, bias_kv=False, bias_out=False):\n super().__init__()\n dim_inner = head_dim * num_heads\n kv_dim = kv_dim if kv_dim is not None else q_dim\n self.num_heads = num_heads\n self.head_dim = head_dim\n\n self.to_q = torch.nn.Linear(q_dim, dim_inner, bias=bias_q)\n self.to_k = torch.nn.Linear(kv_dim, dim_inner, bias=bias_kv)\n self.to_v = torch.nn.Linear(kv_dim, dim_inner, bias=bias_kv)\n self.to_out = torch.nn.Linear(dim_inner, q_dim, bias=bias_out)\n\n def torch_forward(self, hidden_states, encoder_hidden_states=None, attn_mask=None):\n if encoder_hidden_states is None:\n encoder_hidden_states = hidden_states\n\n batch_size = encoder_hidden_states.shape[0]\n\n q = self.to_q(hidden_states)\n k = self.to_k(encoder_hidden_states)\n v = self.to_v(encoder_hidden_states)\n\n q = q.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)\n k = k.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)\n v = v.view(batch_size, -1, self.num_heads, self.head_dim).transpose(1, 2)\n\n hidden_states = torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=attn_mask)\n hidden_states = hidden_states.transpose(1, 2).reshape(batch_size, -1, self.num_heads * self.head_dim)\n hidden_states = hidden_states.to(q.dtype)\n\n hidden_states = self.to_out(hidden_states)\n\n return hidden_states\n \n def xformers_forward(self, hidden_states, encoder_hidden_states=None, attn_mask=None):\n if encoder_hidden_states is None:\n encoder_hidden_states = hidden_states\n\n q = self.to_q(hidden_states)\n k = self.to_k(encoder_hidden_states)\n v = self.to_v(encoder_hidden_states)\n\n q = rearrange(q, \"b f (n d) -> (b n) f d\", n=self.num_heads)\n k = rearrange(k, \"b f (n d) -> (b n) f d\", n=self.num_heads)\n v = rearrange(v, \"b f (n d) -> (b n) f d\", n=self.num_heads)\n\n if attn_mask is not None:\n hidden_states = low_version_attention(q, k, v, attn_bias=attn_mask)\n else:\n import xformers.ops as xops\n hidden_states = xops.memory_efficient_attention(q, k, v)\n hidden_states = rearrange(hidden_states, \"(b n) f d -> b f (n d)\", n=self.num_heads)\n\n hidden_states = hidden_states.to(q.dtype)\n hidden_states = self.to_out(hidden_states)\n\n return hidden_states\n\n def forward(self, hidden_states, encoder_hidden_states=None, attn_mask=None):\n return self.torch_forward(hidden_states, encoder_hidden_states=encoder_hidden_states, attn_mask=attn_mask)" }, { "identifier": "ResnetBlock", "path": "diffsynth/models/sd_unet.py", "snippet": "class ResnetBlock(torch.nn.Module):\n def __init__(self, in_channels, out_channels, temb_channels=None, groups=32, eps=1e-5):\n super().__init__()\n self.norm1 = torch.nn.GroupNorm(num_groups=groups, num_channels=in_channels, eps=eps, affine=True)\n self.conv1 = torch.nn.Conv2d(in_channels, out_channels, kernel_size=3, stride=1, padding=1)\n if temb_channels is not None:\n self.time_emb_proj = torch.nn.Linear(temb_channels, out_channels)\n self.norm2 = torch.nn.GroupNorm(num_groups=groups, num_channels=out_channels, eps=eps, affine=True)\n self.conv2 = torch.nn.Conv2d(out_channels, out_channels, kernel_size=3, stride=1, padding=1)\n self.nonlinearity = torch.nn.SiLU()\n self.conv_shortcut = None\n if in_channels != out_channels:\n self.conv_shortcut = torch.nn.Conv2d(in_channels, out_channels, kernel_size=1, stride=1, padding=0, bias=True)\n\n def forward(self, hidden_states, time_emb, text_emb, res_stack, **kwargs):\n x = hidden_states\n x = self.norm1(x)\n x = self.nonlinearity(x)\n x = self.conv1(x)\n if time_emb is not None:\n emb = self.nonlinearity(time_emb)\n emb = self.time_emb_proj(emb)[:, :, None, None]\n x = x + emb\n x = self.norm2(x)\n x = self.nonlinearity(x)\n x = self.conv2(x)\n if self.conv_shortcut is not None:\n hidden_states = self.conv_shortcut(hidden_states)\n hidden_states = hidden_states + x\n return hidden_states, time_emb, text_emb, res_stack" }, { "identifier": "UpSampler", "path": "diffsynth/models/sd_unet.py", "snippet": "class UpSampler(torch.nn.Module):\n def __init__(self, channels):\n super().__init__()\n self.conv = torch.nn.Conv2d(channels, channels, 3, padding=1)\n\n def forward(self, hidden_states, time_emb, text_emb, res_stack, **kwargs):\n hidden_states = torch.nn.functional.interpolate(hidden_states, scale_factor=2.0, mode=\"nearest\")\n hidden_states = self.conv(hidden_states)\n return hidden_states, time_emb, text_emb, res_stack" }, { "identifier": "TileWorker", "path": "diffsynth/models/tiler.py", "snippet": "class TileWorker:\n def __init__(self):\n pass\n\n\n def mask(self, height, width, border_width):\n # Create a mask with shape (height, width).\n # The centre area is filled with 1, and the border line is filled with values in range (0, 1].\n x = torch.arange(height).repeat(width, 1).T\n y = torch.arange(width).repeat(height, 1)\n mask = torch.stack([x + 1, height - x, y + 1, width - y]).min(dim=0).values\n mask = (mask / border_width).clip(0, 1)\n return mask\n\n\n def tile(self, model_input, tile_size, tile_stride, tile_device, tile_dtype):\n # Convert a tensor (b, c, h, w) to (b, c, tile_size, tile_size, tile_num)\n batch_size, channel, _, _ = model_input.shape\n model_input = model_input.to(device=tile_device, dtype=tile_dtype)\n unfold_operator = torch.nn.Unfold(\n kernel_size=(tile_size, tile_size),\n stride=(tile_stride, tile_stride)\n )\n model_input = unfold_operator(model_input)\n model_input = model_input.view((batch_size, channel, tile_size, tile_size, -1))\n\n return model_input\n\n\n def tiled_inference(self, forward_fn, model_input, tile_batch_size, inference_device, inference_dtype, tile_device, tile_dtype):\n # Call y=forward_fn(x) for each tile\n tile_num = model_input.shape[-1]\n model_output_stack = []\n\n for tile_id in range(0, tile_num, tile_batch_size):\n\n # process input\n tile_id_ = min(tile_id + tile_batch_size, tile_num)\n x = model_input[:, :, :, :, tile_id: tile_id_]\n x = x.to(device=inference_device, dtype=inference_dtype)\n x = rearrange(x, \"b c h w n -> (n b) c h w\")\n\n # process output\n y = forward_fn(x)\n y = rearrange(y, \"(n b) c h w -> b c h w n\", n=tile_id_-tile_id)\n y = y.to(device=tile_device, dtype=tile_dtype)\n model_output_stack.append(y)\n\n model_output = torch.concat(model_output_stack, dim=-1)\n return model_output\n\n\n def io_scale(self, model_output, tile_size):\n # Determine the size modification happend in forward_fn\n # We only consider the same scale on height and width.\n io_scale = model_output.shape[2] / tile_size\n return io_scale\n \n\n def untile(self, model_output, height, width, tile_size, tile_stride, border_width, tile_device, tile_dtype):\n # The reversed function of tile\n mask = self.mask(tile_size, tile_size, border_width)\n mask = mask.to(device=tile_device, dtype=tile_dtype)\n mask = rearrange(mask, \"h w -> 1 1 h w 1\")\n model_output = model_output * mask\n\n fold_operator = torch.nn.Fold(\n output_size=(height, width),\n kernel_size=(tile_size, tile_size),\n stride=(tile_stride, tile_stride)\n )\n mask = repeat(mask[0, 0, :, :, 0], \"h w -> 1 (h w) n\", n=model_output.shape[-1])\n model_output = rearrange(model_output, \"b c h w n -> b (c h w) n\")\n model_output = fold_operator(model_output) / fold_operator(mask)\n\n return model_output\n\n\n def tiled_forward(self, forward_fn, model_input, tile_size, tile_stride, tile_batch_size=1, tile_device=\"cpu\", tile_dtype=torch.float32, border_width=None):\n # Prepare\n inference_device, inference_dtype = model_input.device, model_input.dtype\n height, width = model_input.shape[2], model_input.shape[3]\n border_width = int(tile_stride*0.5) if border_width is None else border_width\n\n # tile\n model_input = self.tile(model_input, tile_size, tile_stride, tile_device, tile_dtype)\n\n # inference\n model_output = self.tiled_inference(forward_fn, model_input, tile_batch_size, inference_device, inference_dtype, tile_device, tile_dtype)\n\n # resize\n io_scale = self.io_scale(model_output, tile_size)\n height, width = int(height*io_scale), int(width*io_scale)\n tile_size, tile_stride = int(tile_size*io_scale), int(tile_stride*io_scale)\n border_width = int(border_width*io_scale)\n\n # untile\n model_output = self.untile(model_output, height, width, tile_size, tile_stride, border_width, tile_device, tile_dtype)\n \n # Done!\n model_output = model_output.to(device=inference_device, dtype=inference_dtype)\n return model_output" } ]

[ { "identifier": "RotatingBufferCache", "path": "mixtral/cache.py", "snippet": "class RotatingBufferCache:\n \"\"\"\n This is an example that implements a less naive rotating buffer cache, allowing for variable length sequences.\n Allocated cache is rectangular which is wasteful (see PagedAttention for better mechanisms)\n \"\"\"\n def __init__(self, n_layers: int, max_batch_size: int, sliding_window: int, n_kv_heads: int, head_dim: int):\n\n self.sliding_window = sliding_window\n self.n_kv_heads = n_kv_heads\n self.head_dim = head_dim\n\n self.cache_k = torch.empty((\n n_layers,\n max_batch_size,\n sliding_window,\n n_kv_heads,\n head_dim\n ))\n self.cache_v = torch.empty((\n n_layers,\n max_batch_size,\n sliding_window,\n n_kv_heads,\n head_dim\n ))\n # holds the valid length for each batch element in the cache\n self.kv_seqlens = None\n\n def get_view(self, layer_id: int, metadata: RotatingCacheInputMetadata) -> CacheView:\n return CacheView(self.cache_k[layer_id], self.cache_v[layer_id], metadata, self.kv_seqlens)\n\n def reset(self):\n self.kv_seqlens = None\n\n def init_kvseqlens(self, batch_size: int):\n self.kv_seqlens = torch.zeros((batch_size,), device=self.device, dtype=torch.long)\n\n @property\n def device(self):\n return self.cache_k.device\n\n def to(self, device: torch.device, dtype: torch.dtype):\n self.cache_k = self.cache_k.to(device=device, dtype=dtype)\n self.cache_v = self.cache_v.to(device=device, dtype=dtype)\n\n return self\n\n def update_seqlens(self, seqlens: List[int]):\n self.kv_seqlens += torch.tensor(seqlens, device=self.device, dtype=torch.long)\n\n def get_input_metadata(self, seqlens: List[int]) -> RotatingCacheInputMetadata:\n \"\"\"\n inpput = seqlens [5,7,2] // seqpos [0, 1, 3] // sliding_window 3\n --> only cache last 3 tokens in each sequence\n - to_cache_mask = [0 0 1 1 1 | 0 0 0 0 1 1 1 | 1 1]\n - cached_elements = [3 | 3 | 2]\n --> absolute positions are used for rope\n - positions = [0 1 2 3 4 | 1 2 3 4 5 6 7 | 3 4]\n --> cache positions are positions cache_masked, modulo sliding_window + batch_idx * sliding_window\n - cache_positions = [2 0 1 | 5 3 4 | 6 7]\n \"\"\"\n if self.kv_seqlens is None:\n self.init_kvseqlens(len(seqlens))\n assert len(seqlens) == len(self.kv_seqlens), f\"Batch size is {len(self.kv_seqlens)}, got {len(seqlens)}, did you forget to reset cache?\"\n seqpos = self.kv_seqlens.tolist()\n\n assert len(seqlens) > 0, seqlens\n masks = [\n [x >= seqlen - self.sliding_window for x in range(seqlen)]\n for seqlen in seqlens\n ]\n to_cache_mask = torch.tensor(sum(masks, []), device=self.device, dtype=torch.bool)\n cached_elements = torch.tensor([sum(mask) for mask in masks], device=self.device, dtype=torch.long)\n positions = torch.cat([torch.arange(pos, pos + seqlen) for pos, seqlen in zip(seqpos, seqlens)]).to(device=self.device, dtype=torch.long)\n batch_idx = torch.tensor(sum([[i]*seqlen for i, seqlen in enumerate(seqlens)], []), device=self.device, dtype=torch.long)\n cache_positions = positions % self.sliding_window + batch_idx * self.sliding_window\n\n first_prefill = seqpos[0] == 0\n subsequent_prefill = any(seqlen > 1 for seqlen in seqlens)\n if first_prefill:\n assert all([pos == 0 for pos in seqpos]), (seqpos)\n mask = BlockDiagonalCausalMask.from_seqlens(seqlens).make_local_attention(self.sliding_window)\n elif subsequent_prefill:\n mask = BlockDiagonalMask.from_seqlens(\n q_seqlen=seqlens,\n kv_seqlen=[s + cached_s.clamp(max=self.sliding_window).item() for (s, cached_s) in zip(seqlens, self.kv_seqlens)]\n ).make_local_attention_from_bottomright(self.sliding_window)\n else:\n mask = BlockDiagonalCausalWithOffsetPaddedKeysMask.from_seqlens(\n q_seqlen=seqlens,\n kv_padding=self.sliding_window,\n kv_seqlen=(self.kv_seqlens + cached_elements).clamp(max=self.sliding_window).tolist()\n )\n\n return RotatingCacheInputMetadata(\n positions=positions,\n to_cache_mask=to_cache_mask,\n cached_elements=cached_elements,\n cache_positions=cache_positions[to_cache_mask],\n prefill=first_prefill or subsequent_prefill,\n mask=mask,\n seqlens=seqlens,\n )" }, { "identifier": "Transformer", "path": "mixtral/model.py", "snippet": "class Transformer(nn.Module):\n def __init__(self, args: ModelArgs, devices: List[str], dtype=torch.float16):\n super().__init__()\n self.args = args\n self.vocab_size = args.vocab_size\n self.n_layers = args.n_layers\n assert self.vocab_size > 0\n\n self.tok_embeddings = nn.Embedding(args.vocab_size, args.dim, device='meta', dtype=dtype)\n self.tok_embeddings.to_empty(device=devices[0])\n\n self.layers = torch.nn.ModuleList(\n [\n TransformerBlock(args=args, device=devices[(i * len(devices)) // args.n_layers], dtype=dtype)\n for i in range(args.n_layers)\n ]\n )\n\n self.norm = RMSNorm(args.dim, eps=args.norm_eps).to(devices[0], dtype=dtype)\n\n self.output = nn.Linear(\n args.dim,\n args.vocab_size,\n bias=False,\n device='meta',\n dtype=dtype\n )\n self.output.to_empty(device=devices[0])\n\n self.freqs_cis = precompute_freqs_cis(self.args.head_dim, 128_000, 1e6).to(devices[0])\n\n @property\n def dtype(self) -> torch.dtype:\n return self.tok_embeddings.weight.dtype\n\n @property\n def device(self) -> torch.device:\n return self.tok_embeddings.weight.device\n\n def forward_partial(\n self,\n input_ids: torch.Tensor,\n seqlens: List[int],\n cache: Optional[RotatingBufferCache]=None,\n ) -> torch.Tensor:\n assert len(seqlens) <= self.args.max_batch_size, f\"Max batch size is {self.args.max_batch_size}, got batch size of {len(seqlens)}\"\n assert sum(seqlens) == input_ids.shape[0], (sum(seqlens), input_ids.shape[0])\n if cache is not None:\n input_metadata = cache.get_input_metadata(seqlens)\n else:\n input_metadata = SimpleInputMetadata.from_seqlens(seqlens, self.device)\n h = self.tok_embeddings(input_ids)\n freqs_cis = self.freqs_cis[input_metadata.positions]\n\n for layer_id, layer in enumerate(self.layers):\n cache_view = None if cache is None else cache.get_view(layer_id, input_metadata)\n h = layer(h, freqs_cis, cache_view)\n \n h = h.to(self.norm.weight.device)\n \n if cache is not None:\n cache.update_seqlens(seqlens)\n\n return self.norm(h)\n\n def forward(\n self,\n input_ids: torch.Tensor,\n seqlens: List[int],\n cache: Optional[RotatingBufferCache]=None,\n ) -> torch.Tensor:\n return self.output(self.forward_partial(\n input_ids, seqlens, cache=cache\n )).float()\n\n @staticmethod\n def from_folder(folder: Path, max_batch_size: int = 1, devices=['cuda'], dtype=torch.float16) -> \"Transformer\":\n with open(folder / 'params.json', 'r') as f:\n model_args = ModelArgs(**json.loads(f.read()))\n model_args.max_batch_size = max_batch_size\n model = Transformer(model_args, devices, dtype=dtype)\n loaded = torch.load(folder / 'consolidated.00.pth')\n model.load_state_dict(loaded)\n return model" }, { "identifier": "Tokenizer", "path": "mixtral/tokenizer.py", "snippet": "class Tokenizer:\n def __init__(self, model_path: str):\n assert Path(model_path).exists(), model_path\n self._model = SentencePieceProcessor(model_file=model_path)\n assert self._model.vocab_size() == self._model.get_piece_size()\n\n @property\n def n_words(self) -> int:\n return self._model.vocab_size()\n\n @property\n def bos_id(self) -> int:\n return self._model.bos_id()\n\n @property\n def eos_id(self) -> int:\n return self._model.eos_id()\n\n @property\n def pad_id(self) -> int:\n return self._model.pad_id()\n\n def encode(self, s: str, bos: bool = True) -> List[int]:\n assert isinstance(s, str)\n t = self._model.encode(s)\n if bos:\n t = [self.bos_id, *t]\n return t\n\n def decode(self, t: List[int]) -> str:\n return self._model.decode(t)" } ]

[ { "identifier": "cfg", "path": "u2seg/UnsupervisedSelectiveLabeling/shared/utils/config_utils.py", "snippet": "class CustomFormatter(logging.Formatter):\n FORMATS = {\n logging.DEBUG: format,\n logging.INFO: grey + format + reset,\n logging.WARNING: yellow + format + reset,\n logging.ERROR: red + format + reset,\n logging.CRITICAL: bold_red + format + reset\n }\n def format(self, record):\ndef init(default_config_file):\ndef is_notebook():\ndef init_cfg(default_config_file=None):" }, { "identifier": "get_transform", "path": "u2seg/UnsupervisedSelectiveLabeling/shared/utils/nn_utils.py", "snippet": "class ModelEMA(object):\n def __init__(self, model, decay):\n def update(self, model):\ndef seed_everything(seed):\ndef save_npy(filename, content):\ndef load_npy(filename, allow_pickle=False):\ndef get_transform(transform_name):\ndef single_model(state_dict):\ndef get_feats_list(model, train_memory_loader, CLIP=False, feat_dim=None, recompute=False, dataparallel=False, force_no_extra_kwargs=False, **kwargs):\ndef kNN(x_train, x_test, K=20):\ndef partitioned_kNN(feats_list, K=20, recompute=False, partitions_size=130000, verify=False):\n def get_sampled_data(ind):\n def dist(a, b):\ndef KMeans(x, seed, K=10, Niter=10, init_inds=None, verbose=True, force_no_lazy_tensor=False):\n def _LazyTensor(x): return x\ndef run_kMeans(feats_list, num_centroids, final_sample_num, Niter, recompute=False, use_cuda=True, seed=None, force_no_lazy_tensor=False, save=True):\ndef get_selection_without_reg(cluster_labels, neighbors_dist, centroid_ordering, final_sample_num):\ndef get_selection_without_reg_outliers(data, neighbors_dist, cluster_labels, num_centroids, iters=1, final_sample_num=None, w=1, momentum=0.5, horizon_num=256, alpha=1, exclude_same_cluster=False, verbose=False):\ndef get_selection(selection_fn, *args, seed=None, recompute=True, save=True, pass_seed=False, **kwargs):\n N, D = x.shape # Number of samples, dimension of the ambient space" } ]

[ { "identifier": "checkpoint", "path": "control_net/ldm/modules/diffusionmodules/util.py", "snippet": "def checkpoint(func, inputs, params, flag):\n \"\"\"\n Evaluate a function without caching intermediate activations, allowing for\n reduced memory at the expense of extra compute in the backward pass.\n :param func: the function to evaluate.\n :param inputs: the argument sequence to pass to `func`.\n :param params: a sequence of parameters `func` depends on but does not\n explicitly take as arguments.\n :param flag: if False, disable gradient checkpointing.\n \"\"\"\n if flag:\n args = tuple(inputs) + tuple(params)\n return CheckpointFunction.apply(func, len(inputs), *args)\n else:\n return func(*inputs)" }, { "identifier": "conv_nd", "path": "control_net/ldm/modules/diffusionmodules/util.py", "snippet": "def conv_nd(dims, *args, **kwargs):\n \"\"\"\n Create a 1D, 2D, or 3D convolution module.\n \"\"\"\n if dims == 1:\n return nn.Conv1d(*args, **kwargs)\n elif dims == 2:\n return nn.Conv2d(*args, **kwargs)\n elif dims == 3:\n return nn.Conv3d(*args, **kwargs)\n raise ValueError(f\"unsupported dimensions: {dims}\")" }, { "identifier": "linear", "path": "control_net/ldm/modules/diffusionmodules/util.py", "snippet": "def linear(*args, **kwargs):\n \"\"\"\n Create a linear module.\n \"\"\"\n return nn.Linear(*args, **kwargs)" }, { "identifier": "avg_pool_nd", "path": "control_net/ldm/modules/diffusionmodules/util.py", "snippet": "def avg_pool_nd(dims, *args, **kwargs):\n \"\"\"\n Create a 1D, 2D, or 3D average pooling module.\n \"\"\"\n if dims == 1:\n return nn.AvgPool1d(*args, **kwargs)\n elif dims == 2:\n return nn.AvgPool2d(*args, **kwargs)\n elif dims == 3:\n return nn.AvgPool3d(*args, **kwargs)\n raise ValueError(f\"unsupported dimensions: {dims}\")" }, { "identifier": "zero_module", "path": "control_net/ldm/modules/diffusionmodules/util.py", "snippet": "def zero_module(module):\n \"\"\"\n Zero out the parameters of a module and return it.\n \"\"\"\n for p in module.parameters():\n p.detach().zero_()\n return module" }, { "identifier": "normalization", "path": "control_net/ldm/modules/diffusionmodules/util.py", "snippet": "def normalization(channels):\n \"\"\"\n Make a standard normalization layer.\n :param channels: number of input channels.\n :return: an nn.Module for normalization.\n \"\"\"\n return GroupNorm32(32, channels)" }, { "identifier": "timestep_embedding", "path": "control_net/ldm/modules/diffusionmodules/util.py", "snippet": "def timestep_embedding(timesteps, dim, max_period=10000, repeat_only=False):\n \"\"\"\n Create sinusoidal timestep embeddings.\n :param timesteps: a 1-D Tensor of N indices, one per batch element.\n These may be fractional.\n :param dim: the dimension of the output.\n :param max_period: controls the minimum frequency of the embeddings.\n :return: an [N x dim] Tensor of positional embeddings.\n \"\"\"\n if not repeat_only:\n half = dim // 2\n freqs = torch.exp(\n -math.log(max_period) * torch.arange(start=0, end=half, dtype=torch.float32) / half\n ).to(device=timesteps.device)\n args = timesteps[:, None].float() * freqs[None]\n embedding = torch.cat([torch.cos(args), torch.sin(args)], dim=-1)\n if dim % 2:\n embedding = torch.cat([embedding, torch.zeros_like(embedding[:, :1])], dim=-1)\n else:\n embedding = repeat(timesteps, 'b -> b d', d=dim)\n return embedding" }, { "identifier": "SpatialTransformer", "path": "control_net/ldm/modules/attention.py", "snippet": "class SpatialTransformer(nn.Module):\n \"\"\"\n Transformer block for image-like data.\n First, project the input (aka embedding)\n and reshape to b, t, d.\n Then apply standard transformer action.\n Finally, reshape to image\n NEW: use_linear for more efficiency instead of the 1x1 convs\n \"\"\"\n def __init__(self, in_channels, n_heads, d_head,\n depth=1, dropout=0., context_dim=None,\n disable_self_attn=False, use_linear=False,\n use_checkpoint=True):\n super().__init__()\n if exists(context_dim) and not isinstance(context_dim, list):\n context_dim = [context_dim]\n self.in_channels = in_channels\n inner_dim = n_heads * d_head\n self.norm = Normalize(in_channels)\n if not use_linear:\n self.proj_in = nn.Conv2d(in_channels,\n inner_dim,\n kernel_size=1,\n stride=1,\n padding=0)\n else:\n self.proj_in = nn.Linear(in_channels, inner_dim)\n\n self.transformer_blocks = nn.ModuleList(\n [BasicTransformerBlock(inner_dim, n_heads, d_head, dropout=dropout, context_dim=context_dim[d],\n disable_self_attn=disable_self_attn, checkpoint=use_checkpoint)\n for d in range(depth)]\n )\n if not use_linear:\n self.proj_out = zero_module(nn.Conv2d(inner_dim,\n in_channels,\n kernel_size=1,\n stride=1,\n padding=0))\n else:\n self.proj_out = zero_module(nn.Linear(in_channels, inner_dim))\n self.use_linear = use_linear\n\n def forward(self, x, context=None):\n # note: if no context is given, cross-attention defaults to self-attention\n if not isinstance(context, list):\n context = [context]\n b, c, h, w = x.shape\n x_in = x\n x = self.norm(x)\n if not self.use_linear:\n x = self.proj_in(x)\n x = rearrange(x, 'b c h w -> b (h w) c').contiguous()\n if self.use_linear:\n x = self.proj_in(x)\n for i, block in enumerate(self.transformer_blocks):\n x = block(x, context=context[i])\n if self.use_linear:\n x = self.proj_out(x)\n x = rearrange(x, 'b (h w) c -> b c h w', h=h, w=w).contiguous()\n if not self.use_linear:\n x = self.proj_out(x)\n return x + x_in" }, { "identifier": "SLTQueryTransformer", "path": "control_net/ldm/modules/attention.py", "snippet": "class SLTQueryTransformer(nn.Module):\n \"\"\"\n Transformer block for image-like data.\n First, project the input (aka embedding)\n and reshape to b, t, d.\n Then apply standard transformer action.\n Finally, reshape to image\n NEW: use_linear for more efficiency instead of the 1x1 convs\n \"\"\"\n def __init__(self, in_channels, n_heads, d_head,\n depth=1, dropout=0., context_dim=None,\n disable_self_attn=False, use_linear=False,\n use_checkpoint=True):\n super().__init__()\n if exists(context_dim) and not isinstance(context_dim, list):\n context_dim = [context_dim]\n\n # self.in_channels = in_channels\n in_channels_with_rays = in_channels + 6 # TODO: Verify\n\n inner_dim = n_heads * d_head\n self.norm = Normalize(in_channels)\n if not use_linear:\n self.proj_in = nn.Conv2d(in_channels_with_rays,\n inner_dim,\n kernel_size=1,\n stride=1,\n padding=0)\n else:\n self.proj_in = nn.Linear(in_channels_with_rays, inner_dim)\n\n self.transformer_blocks = nn.ModuleList(\n [BasicTransformerBlock(inner_dim, n_heads, d_head, dropout=dropout, context_dim=context_dim[d],\n disable_self_attn=disable_self_attn, checkpoint=use_checkpoint)\n for d in range(depth)]\n )\n if not use_linear:\n self.proj_out = zero_module(nn.Conv2d(inner_dim,\n in_channels,\n kernel_size=1,\n stride=1,\n padding=0))\n else:\n self.proj_out = zero_module(nn.Linear(in_channels, inner_dim))\n self.use_linear = use_linear\n\n @staticmethod\n def _get_ray_condition(query_cameras, x_shape, device):\n\n b, _, h, w = x_shape\n\n if query_cameras[0] is not None:\n grid_rays, _ = get_grid_rays_gpu(\n query_cameras, image_size=(h, w), min_x=1, max_x=-1,\n min_y=1, max_y=-1\n ) # (B, H*W, 6)\n\n plucker_rays = get_plucker_parameterization(grid_rays) # (B, H*W, 6)\n plucker_rays = torch.reshape(plucker_rays, (b, h, w, 6))\n plucker_rays = torch.permute(plucker_rays, (0, 3, 1, 2)).contiguous()\n\n else:\n plucker_rays = torch.zeros((b, 6, h, w), dtype=torch.float32).to(device)\n\n return plucker_rays # (B, 6, H, W)\n\n def forward(self, x, slt, query_cameras):\n # slt is the Set Latent Representation\n if not isinstance(slt, list):\n slt = [slt]\n b, c, h, w = x.shape\n x_in = x\n x = self.norm(x)\n\n # NOTE: Current design decision is to not apply group norm on rays.\n # TODO: Ask if the above decision is fine or not.\n rays = self._get_ray_condition(query_cameras, x.shape, x.device)\n x = torch.cat((x, rays), dim = 1) # (B, C+6, H, W)\n\n if not self.use_linear:\n x = self.proj_in(x)\n x = rearrange(x, 'b c h w -> b (h w) c').contiguous()\n if self.use_linear:\n x = self.proj_in(x)\n for i, block in enumerate(self.transformer_blocks):\n x = block(x, context=slt[i])\n if self.use_linear:\n x = self.proj_out(x)\n x = rearrange(x, 'b (h w) c -> b c h w', h=h, w=w).contiguous()\n if not self.use_linear:\n x = self.proj_out(x)\n return x + x_in" }, { "identifier": "exists", "path": "control_net/ldm/util.py", "snippet": "def exists(x):\n return x is not None" } ]

[ { "identifier": "Txt2ImgIterableBaseDataset", "path": "ldm/data/base.py", "snippet": "class Txt2ImgIterableBaseDataset(IterableDataset):\n '''\n Define an interface to make the IterableDatasets for text2img data chainable\n '''\n\n def __init__(self, num_records=0, valid_ids=None, size=256):\n super().__init__()\n self.num_records = num_records\n self.valid_ids = valid_ids\n self.sample_ids = valid_ids\n self.size = size\n\n print(\n f'{self.__class__.__name__} dataset contains {self.__len__()} examples.'\n )\n\n def __len__(self):\n return self.num_records\n\n @abstractmethod\n def __iter__(self):\n pass" }, { "identifier": "instantiate_from_config", "path": "ldm/util.py", "snippet": "def instantiate_from_config(config):\n if not 'target' in config:\n\n print(config)\n if config == '__is_first_stage__':\n return None\n elif config == '__is_unconditional__':\n return None\n raise KeyError('Expected key `target` to instantiate.')\n return get_obj_from_str(config['target'])(**config.get('params', dict()))" } ]

[ { "identifier": "get_groups_simple", "path": "reproduction/crowdsourcing/annotate/preprocessing/mask_creation_utils.py", "snippet": "TARGET_STEP = 100\nSKIP_LOGGING = True\nclass GroupItem(TypedDict):\nclass FinalGroup(TypedDict):\ndef jitter(size: float) -> float:\ndef bound(v, lo, hi):\ndef _load_final_group_from_json(json_dict) -> FinalGroup:\ndef load_final_group_from_json(json_dict) -> FinalGrouping:\ndef get_grid(\n step: int, \n top_left: Point, \n bottom_right: Point, \n noise: Optional[float] = None\n) -> List[Point]:\ndef get_missing_points_greedy(mask: np.ndarray, min_size: int) -> List[Point]:\ndef get_points_from_canny_greedy(\n image: np.ndarray, \n distance_threshold: int = 40, \n jitter_amount: int = 40,\n num_extra: int = 3,\n) -> List[Point]:\ndef predict_all(\n predictor: \"SamPredictor\", \n image: np.ndarray, \n step: int = TARGET_STEP, \n top_left: Optional[Point] = None, \n bottom_right: Optional[Point] = None, \n containing_mask: Optional[np.ndarray] = None\n) -> Dict[Point, List[EfficientMask]]:\ndef predict_for_points(\n predictor: \"SamPredictor\", \n points: List[Point],\n) -> Dict[Point, List[EfficientMask]]:\ndef predict_for_bounded_points(\n predictor: \"SamPredictor\", \n image: np.ndarray, \n points: List[Point], \n mask: EfficientMask,\n) -> Dict[Point, List[EfficientMask]]:\ndef get_canny_masks(\n predictor: \"SamPredictor\", \n image: np.ndarray, \n distance_threshold: int = 40, \n jitter_amount: int = 40\n):\ndef process_best_largest(\n results: Dict[Point, List[EfficientMask]], \n penalty_gap: float = 0.2,\n) -> Dict[Point, Dict[MaskMergeKey, EfficientMask]]:\ndef get_groups(\n processed_results: Dict[Point, Dict[MaskMergeKey, EfficientMask]], \n merge_key: MaskMergeKey = 'best', \n groups: Optional[GroupDict] = None,\n) -> GroupDict:\ndef get_groups_simple(\n sam_results: List[EfficientMask],\n) -> FinalGrouping:\ndef print_groups(groups: FinalGrouping) -> None:\n def _get_group_map(curr_g: FinalGrouping) -> Dict[Union[int, str], Any]:\ndef refine_groups_simple(groups: FinalGrouping, merge_thresh = 0.03) -> FinalGrouping:\ndef first_iteration_groups(\n predictor: \"SamPredictor\",\n processed_results: Dict[Point, Dict[MaskMergeKey, EfficientMask]], \n step: int, \n merge_key: MaskMergeKey = \"largest\",\n) -> GroupDict:\ndef get_subgroup_mask_lists(\n groups: GroupDict, \n base_masks: Dict[Point, List[EfficientMask]], \n canny_masks: Dict[Point, List[EfficientMask]], \n score_cutoff: float = 0.7, \n retain_best: bool = False,\n) -> GroupDict:\ndef compute_subgroups(\n group_mask_item: GroupItem, \n contained_in_thresh: float = 0.90, \n outer_sim_thresh: float = 0.77, \n mutual_sim_thresh: float = 0.85, \n retain_best: bool = False,\n) -> GroupDict:\ndef add_points_in_mask(\n predictor: \"SamPredictor\", \n image: np.ndarray, \n item: GroupItem, \n score_cutoff: float = 0.7,\n num_points = 5,\n) -> GroupItem:\ndef compute_subgroup_recursively(\n predictor: \"SamPredictor\", \n image: np.ndarray, \n group_mask_item: GroupItem, \n score_cutoff: float = 0.7, \n contained_in_thresh: float = 0.90, \n outer_sim_thresh: float = 0.77, \n mutual_sim_thresh: float = 0.85, \n retain_best: bool = False, \n depth: int = 0,\n) -> FinalGroup:\ndef compute_group_tree(\n predictor: \"SamPredictor\", \n image: np.ndarray, \n score_cutoff: float = 0.7, \n contained_in_thresh: float = 0.9, \n outer_sim_thresh: float = 0.8, \n mutual_sim_thresh: float = 0.9, \n retain_best: bool = False,\n) -> FinalGrouping:" }, { "identifier": "EfficientMask", "path": "reproduction/crowdsourcing/annotate/preprocessing/efficient_mask.py", "snippet": "class EfficientMask():\n \"\"\"Class for more efficient mask mask over full numpy ndarrays\"\"\"\n def __init__(self, mask: np.ndarray, score: float, size: Optional[int] = None):\n self.mask = mask\n self.score = score\n self._size: Optional[int] = size\n self._tlbr: Optional[Tuple[Point, Point]] = None\n \n def __repr__(self) -> str:\n return f\"<EM : {self.get_size()}, {self.get_tlbr()}>\"\n \n def _reset_cache(self):\n self._tlbr = None\n self._size = None\n \n def set_to(self, other: \"EfficientMask\"):\n \"\"\"Set this mask's values to that of other\"\"\"\n self.mask = other.mask\n self.score = other.score\n self._size = other._size\n self._tlbr = other._tlbr\n \n def get_tlbr(self) -> Tuple[Point, Point]:\n \"\"\"Return the top left and bottom right bounds of this mask\"\"\"\n if self._tlbr is None:\n try:\n np_where = np.where(self.mask == True)\n left = np.min(np_where[1])\n right = np.max(np_where[1]) + 1\n top = np.min(np_where[0])\n bottom = np.max(np_where[0]) + 1\n except ValueError:\n top, left, bottom, right = (0, 0, 0, 0)\n self._tlbr = ((cast(Ydm, top), cast(Xdm, left)), (cast(Ydm, bottom), cast(Xdm, right)))\n return self._tlbr\n \n def get_size(self) -> int:\n \"\"\"Return the total number of true pixels in this mask\"\"\"\n if self._size is None:\n (top, left), (bottom, right) = self.get_tlbr()\n self._size = np.sum(self.mask[top:bottom,left:right]*1)\n return self._size\n \n def get_density(self) -> float:\n \"\"\"Provide rough density with number of pixels and bbox size\"\"\"\n size = self.get_size()\n (t, l), (b, r) = self.get_tlbr()\n area = (b-t) * (r-l) + 1\n return size / area\n \n def dense_score(self) -> float:\n \"\"\"Return the score times the density, a heuristic for quality\"\"\"\n return self.score * math.sqrt(self.get_density())\n \n def _bbox_overlaps(self, other: \"EfficientMask\") -> bool:\n \"\"\"Check points of opposite diagonals in each other bbox\"\"\"\n (t1, l1), (b1, r1) = self.get_tlbr()\n (t2, l2), (b2, r2) = other.get_tlbr()\n return (\n point_in_box(t1, l1, other.get_tlbr()) or \n point_in_box(b1, r1, other.get_tlbr()) or \n point_in_box(t2, r2, self.get_tlbr()) or \n point_in_box(b2, l2, self.get_tlbr()) \n )\n \n def _get_overlap_submask(self, other: \"EfficientMask\") -> np.ndarray:\n \"\"\"Get a classic ndarray of pixels in the overlap between this and other\"\"\"\n if not self._bbox_overlaps(other):\n return np.array([])\n (t1, l1), (b1, r1) = self.get_tlbr()\n (t2, l2), (b2, r2) = other.get_tlbr()\n maxt, maxl = max(t1, t2), max(l1, l2)\n minb, minr = min(b1, b2), min(r1, r2)\n return (self.mask[maxt:minb,maxl:minr]*1 + other.mask[maxt:minb,maxl:minr]*1 == 2)\n \n def _get_xor_submask(self, other: \"EfficientMask\") -> np.ndarray:\n \"\"\"Get a classic ndarray of pixels in the xor between this and other\"\"\"\n if not self._bbox_overlaps(other):\n return np.array([])\n (t1, l1), (b1, r1) = self.get_tlbr()\n (t2, l2), (b2, r2) = other.get_tlbr()\n mint, minl = min(t1, t2), min(l1, l2)\n maxb, maxr = max(b1, b2), max(r1, r2)\n return (self.mask[mint:maxb,minl:maxr]*1 + other.mask[mint:maxb,minl:maxr]*1 == 1)\n \n def intersect(self, other: \"EfficientMask\") -> \"EfficientMask\":\n \"\"\"Return an efficient mask of the overlap between this and other\"\"\"\n res = np.full(self.mask.shape, False)\n submask = self._get_overlap_submask(other)\n if len(submask) != 0:\n (t1, l1), (b1, r1) = self.get_tlbr()\n (t2, l2), (b2, r2) = other.get_tlbr()\n maxt, maxl = max(t1, t2), max(l1, l2)\n minb, minr = min(b1, b2), min(r1, r2)\n res[maxt:minb,maxl:minr] = submask\n return EfficientMask(res, (self.score + other.score)/2)\n\n def mostly_contained_in(self, out_mask: \"EfficientMask\", thresh: float = 0.95) -> bool:\n \"\"\"Returns True if thresh of self's pixels are in out_mask\"\"\"\n size_in = self.get_size() + 1\n overlap = mask_size(self._get_overlap_submask(out_mask))\n return overlap / size_in > thresh\n \n def overlaps_threshold(self, other: \"EfficientMask\", thresh: float = 0.50) -> bool:\n \"\"\"Returns true if over thresh of either mask is contained in the other\"\"\"\n size_1 = self.get_size() + 1\n size_2 = other.get_size() + 1\n overlap = mask_size(self._get_overlap_submask(other))\n return overlap / size_1 > thresh or overlap / size_2 > thresh\n \n def near_equivalent_to(self, other: \"EfficientMask\", thresh: float = 0.96) -> bool:\n \"\"\"Return true if these two masks have prop overlapping pixels > thresh\"\"\"\n size_1 = self.get_size() + 1\n size_2 = other.get_size() + 1\n if size_1 / size_2 < thresh or size_2 / size_1 < thresh:\n return False\n difference = mask_size(self._get_xor_submask(other))\n if (difference / size_1) > (1-thresh) or (difference / size_2) > (1-thresh):\n return False\n return True\n \n def union(self, other: \"EfficientMask\") -> \"EfficientMask\":\n \"\"\"Return a new efficient mask unioning these\"\"\"\n new_mask = self.mask * 1\n (t2, l2), (b2, r2) = other.get_tlbr()\n new_mask[t2:b2,l2:r2] += other.mask[t2:b2,l2:r2]*1\n return EfficientMask(\n mask=cast(np.ndarray, new_mask > 0),\n score=(self.score + other.score) / 2, # may be more appropriate as weighted mask sizes\n )\n\n def subtract(self, other: \"EfficientMask\") -> \"EfficientMask\":\n \"\"\"Subtract the other mask from this one\"\"\"\n new_mask = self.mask * 1\n (t2, l2), (b2, r2) = other.get_tlbr()\n new_mask[t2:b2,l2:r2] -= other.mask[t2:b2,l2:r2]*1\n return EfficientMask(\n mask=cast(np.ndarray, new_mask == 1),\n score=self.score,\n )" } ]

[ { "identifier": "denoise", "path": "scripts/resemble_enhance/enhancer/inference.py", "snippet": "@torch.inference_mode()\ndef denoise(dwav, sr, device, run_dir=None):\n enhancer = load_enhancer(run_dir, device)\n return inference(model=enhancer.denoiser, dwav=dwav, sr=sr, device=device)" }, { "identifier": "enhance", "path": "scripts/resemble_enhance/enhancer/inference.py", "snippet": "@torch.inference_mode()\ndef enhance(chunk_seconds, chunks_overlap,dwav, sr, device, nfe=32, solver=\"midpoint\", lambd=0.5, tau=0.5, run_dir=None):\n assert 0 < nfe <= 128, f\"nfe must be in (0, 128], got {nfe}\"\n assert solver in (\"midpoint\", \"rk4\", \"euler\"), f\"solver must be in ('midpoint', 'rk4', 'euler'), got {solver}\"\n assert 0 <= lambd <= 1, f\"lambd must be in [0, 1], got {lambd}\"\n assert 0 <= tau <= 1, f\"tau must be in [0, 1], got {tau}\"\n enhancer = load_enhancer(run_dir, device)\n enhancer.configurate_(nfe=nfe, solver=solver, lambd=lambd, tau=tau)\n return inference(model=enhancer, chunk_seconds=chunk_seconds, overlap_seconds=chunks_overlap, dwav=dwav, sr=sr, device=device)" } ]

[ { "identifier": "AttrDict", "path": "dva/attr_dict.py", "snippet": "class AttrDict:\n def __init__(self, entries):\n self.add_entries_(entries)\n\n def keys(self):\n return self.__dict__.keys()\n\n def values(self):\n return self.__dict__.values()\n\n def __getitem__(self, key):\n return self.__dict__[key]\n\n def __setitem__(self, key, value):\n self.__dict__[key] = value\n\n def __delitem__(self, key):\n return self.__dict__.__delitem__(key)\n\n def __contains__(self, key):\n return key in self.__dict__\n\n def __repr__(self):\n return self.__dict__.__repr__()\n\n def __getattr__(self, attr):\n if attr.startswith(\"__\"):\n return self.__getattribute__(attr)\n return self.__dict__[attr]\n\n def items(self):\n return self.__dict__.items()\n\n def __iter__(self):\n return iter(self.items())\n\n def add_entries_(self, entries, overwrite=True):\n for key, value in entries.items():\n if key not in self.__dict__:\n if isinstance(value, dict):\n self.__dict__[key] = AttrDict(value)\n else:\n self.__dict__[key] = value\n else:\n if isinstance(value, dict):\n self.__dict__[key].add_entries_(entries=value, overwrite=overwrite)\n elif overwrite or self.__dict__[key] is None:\n self.__dict__[key] = value\n\n def serialize(self):\n return json.dumps(self, default=self.obj_to_dict, indent=4)\n\n def obj_to_dict(self, obj):\n return obj.__dict__\n\n def get(self, key, default=None):\n return self.__dict__.get(key, default)" }, { "identifier": "compute_v2uv", "path": "dva/geom.py", "snippet": "def compute_v2uv(n_verts, vi, vti, n_max=4):\n \"\"\"Computes mapping from vertex indices to texture indices.\n\n Args:\n vi: [F, 3], triangles\n vti: [F, 3], texture triangles\n n_max: int, max number of texture locations\n\n Returns:\n [n_verts, n_max], texture indices\n \"\"\"\n v2uv_dict = {}\n for i_v, i_uv in zip(vi.reshape(-1), vti.reshape(-1)):\n v2uv_dict.setdefault(i_v, set()).add(i_uv)\n assert len(v2uv_dict) == n_verts\n v2uv = np.zeros((n_verts, n_max), dtype=np.int32)\n for i in range(n_verts):\n vals = sorted(list(v2uv_dict[i]))\n v2uv[i, :] = vals[0]\n v2uv[i, : len(vals)] = np.array(vals)\n return v2uv" }, { "identifier": "compute_neighbours", "path": "dva/geom.py", "snippet": "def compute_neighbours(n_verts, vi, n_max_values=10):\n \"\"\"Computes first-ring neighbours given vertices and faces.\"\"\"\n n_vi = vi.shape[0]\n\n adj = {i: set() for i in range(n_verts)}\n for i in range(n_vi):\n for idx in vi[i]:\n adj[idx] |= set(vi[i]) - set([idx])\n\n nbs_idxs = np.tile(np.arange(n_verts)[:, np.newaxis], (1, n_max_values))\n nbs_weights = np.zeros((n_verts, n_max_values), dtype=np.float32)\n\n for idx in range(n_verts):\n n_values = min(len(adj[idx]), n_max_values)\n nbs_idxs[idx, :n_values] = np.array(list(adj[idx]))[:n_values]\n nbs_weights[idx, :n_values] = -1.0 / n_values\n\n return nbs_idxs, nbs_weights" } ]

[ { "identifier": "ArxivPaper", "path": "backend/models.py", "snippet": "class ArxivPaper(models.Model):\n created_at = models.DateTimeField(auto_now_add=True)\n modified_at = models.DateTimeField(auto_now=True)\n arxiv_id = models.CharField(max_length=20, unique=True)\n\n # fields scraped from the paper page:\n title = models.CharField(max_length=255, db_index=True)\n abstract = models.TextField(db_index=True)\n authors = models.ManyToManyField(Author)\n primary_subject = models.ForeignKey(Subject, on_delete=models.CASCADE, null=True, blank=True)\n subjects = models.ManyToManyField(Subject, related_name=\"papers\")\n comment = models.TextField(null=True, blank=True)\n doi = models.CharField(max_length=255, null=True, blank=True)\n journal_ref = models.CharField(max_length=255, null=True, blank=True)\n publication_date = models.DateField()\n\n # fields we create\n summary = models.TextField(db_index=True)\n total_author_citations = models.IntegerField(default=0, db_index=True)\n citations = models.IntegerField(default=0, db_index=True)\n\n # file fields\n pdf = models.FileField(upload_to=\"pdfs\", null=True, blank=True)\n screenshot = models.ImageField(upload_to=\"screenshots\", null=True, blank=True)\n source_tar = models.FileField(upload_to=\"tar_sources\", null=True, blank=True)\n images = models.ManyToManyField(PaperImage, related_name=\"paper_images\")\n sources = models.ManyToManyField(PaperSource, related_name=\"paper_sources\")\n\n def abstract_link(self) -> str:\n return f\"https://arxiv.org/abs/{self.arxiv_id}\"\n\n def pdf_link(self) -> str:\n return f\"https://arxiv.org/pdf/{self.arxiv_id}.pdf\"\n\n def source_link(self) -> str:\n return f\"https://arxiv.org/e-print/{self.arxiv_id}\"\n\n def __str__(self):\n return self.title" }, { "identifier": "Author", "path": "backend/models.py", "snippet": "class Author(models.Model):\n created_at = models.DateTimeField(auto_now_add=True)\n modified_at = models.DateTimeField(auto_now=True)\n\n name = models.CharField(max_length=255, db_index=True)\n affiliation = models.CharField(max_length=255, null=True, blank=True, db_index=True)\n email = models.EmailField(null=True, blank=True)\n email_domain = models.CharField(max_length=255, null=True, blank=True, db_index=True)\n citations = models.IntegerField(default=0, db_index=True)\n scholar_id = models.CharField(max_length=255, null=True, blank=True)\n\n def __str__(self):\n return self.name" }, { "identifier": "Subject", "path": "backend/models.py", "snippet": "class Subject(models.Model):\n created_at = models.DateTimeField(auto_now_add=True)\n modified_at = models.DateTimeField(auto_now=True)\n\n short_name = models.CharField(max_length=255)\n full_name = models.CharField(max_length=255)\n\n def __str__(self):\n return self.full_name" }, { "identifier": "PaperImage", "path": "backend/models.py", "snippet": "class PaperImage(models.Model):\n created_at = models.DateTimeField(auto_now_add=True)\n modified_at = models.DateTimeField(auto_now=True)\n\n image = models.ImageField(upload_to=\"images\")\n paper = models.ForeignKey(\"ArxivPaper\", on_delete=models.CASCADE)" }, { "identifier": "PaperSource", "path": "backend/models.py", "snippet": "class PaperSource(models.Model):\n created_at = models.DateTimeField(auto_now_add=True)\n modified_at = models.DateTimeField(auto_now=True)\n\n content = models.TextField()\n paper = models.ForeignKey(\"ArxivPaper\", on_delete=models.CASCADE)" } ]

[ { "identifier": "Middlebury_dataset", "path": "data/middlebury_dataloader.py", "snippet": "class Middlebury_dataset(Dataset):\n \"\"\"RGB-D-D Dataset.\"\"\"\n\n def __init__(self, root_dir, scale=8, transform=None):\n \"\"\"\n Args:\n root_dir (string): Directory with all the images.\n scale (float): dataset scale\n transform (callable, optional): Optional transform to be applied on a sample.\n \"\"\"\n\n self.transform = transform\n self.scale = scale\n\n self.GTs = []\n self.RGBs = []\n \n list_dir = os.listdir(root_dir)\n for name in list_dir:\n if name.find('output_color') > -1:\n self.RGBs.append('%s/%s' % (root_dir, name))\n elif name.find('output_depth') > -1:\n self.GTs.append('%s/%s' % (root_dir, name))\n self.RGBs.sort()\n self.GTs.sort()\n\n def __len__(self):\n return len(self.GTs)\n\n def __getitem__(self, idx):\n \n image = np.array(Image.open(self.RGBs[idx]))\n gt = np.array(Image.open(self.GTs[idx]))\n assert gt.shape[0] == image.shape[0] and gt.shape[1] == image.shape[1]\n s = self.scale \n image = modcrop(image, s)\n gt = modcrop(gt, s)\n\n h, w = gt.shape[0], gt.shape[1]\n s = self.scale\n\n lr = np.array(Image.fromarray(gt).resize((w//s,h//s),Image.BICUBIC)).astype(np.float32)\n gt = gt / 255.0\n image = image / 255.0\n lr = lr / 255.0\n \n\n if self.transform:\n image = self.transform(image).float()\n gt = self.transform(np.expand_dims(gt,2))\n lr = self.transform(np.expand_dims(lr,2)).float()\n\n # sample = {'guidance': image, 'lr': lr, 'gt': gt, 'max':maxx, 'min': minn}\n sample = {'guidance': image, 'lr': lr, 'gt': gt}\n return sample" }, { "identifier": "calc_rmse", "path": "utils.py", "snippet": "def calc_rmse(a, b, minmax):\n a = a[6:-6, 6:-6]\n b = b[6:-6, 6:-6]\n \n a = a*(minmax[0]-minmax[1]) + minmax[1]\n b = b*(minmax[0]-minmax[1]) + minmax[1]\n a = a * 100\n b = b * 100\n \n return torch.sqrt(torch.mean(torch.pow(a-b,2)))" }, { "identifier": "rgbdd_calc_rmse", "path": "utils.py", "snippet": "def rgbdd_calc_rmse(gt, out, minmax):\n gt = gt[6:-6, 6:-6]\n out = out[6:-6, 6:-6]\n\n # gt = gt*(minmax[0]-minmax[1]) + minmax[1]\n out = out*(minmax[0]-minmax[1]) + minmax[1]\n gt = gt / 10.0\n out = out / 10.0\n \n return torch.sqrt(torch.mean(torch.pow(gt-out,2)))" }, { "identifier": "midd_calc_rmse", "path": "utils.py", "snippet": "def midd_calc_rmse(gt, out):\n gt = gt[6:-6, 6:-6]\n out = out[6:-6, 6:-6]\n gt = gt * 255.0\n out = out * 255.0\n \n return torch.sqrt(torch.mean(torch.pow(gt-out,2)))" } ]

[ { "identifier": "MRTE", "path": "modules/mrte.py", "snippet": "class MRTE(nn.Module):\n def __init__(\n self, \n mel_bins: int = HIFIGAN_MEL_CHANNELS,\n mel_frames: int = HIFIGAN_HOP_LENGTH,\n attn_dim: int = 512,\n ff_dim: int = 1024,\n n_heads: int = 2,\n n_layers: int = 8,\n ge_kernel_size: int = 31,\n ge_hidden_sizes: List = [HIFIGAN_MEL_CHANNELS, 256, 256, 512, 512],\n ge_activation: str = 'ReLU',\n ge_out_channels: int = 512,\n duration_tokne_ms: float = (HIFIGAN_HOP_LENGTH / HIFIGAN_SR * 1000),\n phone_vocab_size: int = 320,\n dropout: float = 0.1,\n sample_rate: int = HIFIGAN_SR,\n ):\n super(MRTE, self).__init__()\n\n self.n_heads = n_heads\n \n self.phone_embedding = TokenEmbedding(\n dim_model=attn_dim,\n vocab_size=phone_vocab_size,\n dropout=dropout,\n )\n\n self.phone_pos_embedding = SinePositionalEmbedding(\n dim_model=attn_dim,\n dropout=dropout,\n )\n\n self.mel_embedding = nn.Linear(mel_bins, attn_dim)\n self.mel_pos_embedding = SinePositionalEmbedding(\n dim_model=attn_dim,\n dropout=dropout,\n )\n\n self.mel_encoder = TransformerEncoder(\n TransformerEncoderLayer(\n dim=attn_dim,\n ff_dim=ff_dim,\n conv_ff=True,\n n_heads=n_heads,\n dropout=dropout,\n ),\n num_layers=n_layers,\n )\n\n self.phone_encoder = TransformerEncoder(\n TransformerEncoderLayer(\n dim=attn_dim,\n ff_dim=ff_dim,\n conv_ff=True,\n n_heads=n_heads,\n dropout=dropout,\n ),\n num_layers=n_layers,\n )\n\n self.mha = MultiHeadAttention(\n qkv_dim=attn_dim,\n n_heads=n_heads,\n dropout=dropout,\n )\n self.norm = nn.LayerNorm(attn_dim)\n self.activation = nn.ReLU()\n\n self.compress_features = nn.Linear(attn_dim + ge_out_channels, ge_out_channels)\n\n self.ge = ConvNet(\n hidden_sizes = ge_hidden_sizes,\n kernel_size = ge_kernel_size,\n stack_size = 3,\n activation = ge_activation,\n avg_pooling = True\n )\n\n self.length_regulator = LengthRegulator(mel_frames, sample_rate, duration_tokne_ms)\n\n def forward(\n self,\n duration_tokens: torch.Tensor, # (B, T)\n phone: torch.Tensor, # (B, T)\n phone_lens: torch.Tensor, # (B,)\n mel: torch.Tensor, # (B, T, mel_bins)\n mel_lens: torch.Tensor, # (B,)\n ):\n \n phone_emb = self.phone_embedding(phone)\n phone_pos = self.phone_pos_embedding(phone_emb)\n\n mel_emb = self.mel_embedding(mel)\n mel_pos = self.mel_pos_embedding(mel_emb)\n\n mel_context = self.mel_encoder(mel_pos, mel_lens)\n phone_x = self.phone_encoder(phone_pos, phone_lens)\n\n phone_latent = self.mha(phone_x, kv=mel_context)\n phone_latent = self.norm(phone_latent)\n phone_latent = self.activation(phone_latent)\n\n mel = rearrange(mel, \"B T D -> B D T\")\n ge = self.ge(mel)\n ge = ge.unsqueeze(1).repeat(1, phone_latent.shape[1], 1)\n\n out = self.compress_features(torch.cat([ge, phone_latent], dim=-1))\n out = self.length_regulator(phone_latent, duration_tokens)\n return out" }, { "identifier": "VQProsodyEncoder", "path": "modules/vqpe.py", "snippet": "class VQProsodyEncoder(nn.Module):\n def __init__(\n self,\n hidden_sizes: List = [HIFIGAN_MEL_CHANNELS, 256, 256, 512, 512],\n kernel_size: int = 5,\n stack_size: int = 3,\n activation: str = 'ReLU',\n ):\n super(VQProsodyEncoder, self).__init__()\n\n self.convnet = ConvNet(\n hidden_sizes=hidden_sizes,\n kernel_size=kernel_size,\n stack_size=stack_size,\n activation=activation,\n )\n\n self.vq = ResidualVectorQuantizer(\n dimension=512,\n n_q=1,\n bins=1024,\n decay=0.99\n )\n\n def forward(\n self, \n mel: torch.Tensor, # (B, T, mel_bins)\n ):\n \n mel = rearrange(mel, \"B T D -> B D T\")\n ze = self.convnet(mel)\n zq, _, commit_loss = self.vq(ze)\n vq_loss = F.mse_loss(ze.detach(), zq)\n zq = rearrange(zq, \"B D T -> B T D\")\n return zq, commit_loss, vq_loss" }, { "identifier": "ConvNet", "path": "modules/convnet.py", "snippet": "class ConvNet(nn.Module):\n def __init__(\n self,\n hidden_sizes: List = [128, 256, 256, 512, 512],\n kernel_size: int = 5,\n stack_size: int = 3,\n activation: str = 'ReLU',\n avg_pooling: bool = False\n ):\n super(ConvNet, self).__init__()\n # First layer\n layers = [\n nn.Conv1d(\n hidden_sizes[0],\n hidden_sizes[0],\n kernel_size=kernel_size,\n padding=(kernel_size - 1) // 2\n ),\n ]\n # Middle layers\n for i in range(len(hidden_sizes)):\n if i == 0:\n layers += [\n ConvStack(\n hidden_sizes=[hidden_sizes[0]] * stack_size,\n kernel_size=kernel_size,\n activation=activation,\n )\n ]\n else:\n layers += [\n ResidualBlock(\n hidden_sizes=[hidden_sizes[i]] * stack_size,\n kernel_size=kernel_size,\n activation=activation,\n )\n ]\n # Upsample or downsample\n if (i != len(hidden_sizes) - 1) and (hidden_sizes[i] != hidden_sizes[i + 1]):\n layers += [\n nn.Conv1d(\n hidden_sizes[i],\n hidden_sizes[i + 1],\n kernel_size=kernel_size,\n padding=(kernel_size - 1) // 2\n ),\n getattr(nn, activation)(),\n ]\n # Last layer\n if avg_pooling:\n layers += [\n nn.AdaptiveAvgPool1d(1),\n nn.Flatten(),\n ]\n else:\n layers += [\n nn.Conv1d(\n hidden_sizes[-1],\n hidden_sizes[-1],\n kernel_size=kernel_size,\n padding=(kernel_size - 1) // 2\n ),\n ]\n\n self.layers = nn.Sequential(*layers)\n\n def forward(self, x):\n return self.layers(x)" }, { "identifier": "SinePositionalEmbedding", "path": "modules/embedding.py", "snippet": "class SinePositionalEmbedding(nn.Module):\n def __init__(\n self,\n dim_model: int,\n dropout: float = 0.0,\n scale: bool = False,\n alpha: bool = False,\n ):\n super().__init__()\n self.dim_model = dim_model\n self.x_scale = math.sqrt(dim_model) if scale else 1.0\n self.alpha = nn.Parameter(torch.ones(1), requires_grad=alpha)\n self.dropout = torch.nn.Dropout(p=dropout)\n\n self.reverse = False\n self.pe = None\n self.extend_pe(torch.tensor(0.0).expand(1, 4000))\n\n def extend_pe(self, x, offset = 0):\n \"\"\"Reset the positional encodings.\"\"\"\n x_size = x.size(1) + offset\n if self.pe is not None:\n if self.pe.size(1) >= x_size:\n if self.pe.dtype != x.dtype or self.pe.device != x.device:\n self.pe = self.pe.to(dtype=x.dtype, device=x.device)\n return\n pe = torch.zeros(x_size, self.dim_model)\n if self.reverse:\n position = torch.arange(\n x_size - 1, -1, -1.0, dtype=torch.float32\n ).unsqueeze(1)\n else:\n position = torch.arange(\n 0, x_size, dtype=torch.float32\n ).unsqueeze(1)\n div_term = torch.exp(\n torch.arange(0, self.dim_model, 2, dtype=torch.float32)\n * -(math.log(10000.0) / self.dim_model)\n )\n pe[:, 0::2] = torch.sin(position * div_term)\n pe[:, 1::2] = torch.cos(position * div_term)\n pe = pe.unsqueeze(0)\n self.pe = pe.to(device=x.device, dtype=x.dtype).detach()\n\n def forward(self, x: torch.Tensor, offset : int = 0) -> torch.Tensor:\n self.extend_pe(x, offset)\n output = x.unsqueeze(-1) if x.ndim == 2 else x\n output = output * self.x_scale + self.alpha * self.pe[:, offset : x.size(1) + offset]\n return self.dropout(output)" }, { "identifier": "TokenEmbedding", "path": "modules/embedding.py", "snippet": "class TokenEmbedding(nn.Module):\n def __init__(\n self,\n dim_model: int,\n vocab_size: int,\n dropout: float = 0.0,\n ):\n super().__init__()\n\n self.vocab_size = vocab_size\n self.dim_model = dim_model\n\n self.dropout = torch.nn.Dropout(p=dropout)\n self.word_embeddings = nn.Embedding(self.vocab_size, self.dim_model)\n\n @property\n def weight(self) -> torch.Tensor:\n return self.word_embeddings.weight\n\n def embedding(self, index: int) -> torch.Tensor:\n return self.word_embeddings.weight[index : index + 1]\n\n def forward(self, x: torch.Tensor):\n X = self.word_embeddings(x)\n X = self.dropout(X)\n\n return X" }, { "identifier": "TransformerEncoder", "path": "modules/transformer.py", "snippet": "class TransformerEncoder(nn.Module):\n def __init__(\n self,\n encoder_layer: TransformerEncoderLayer,\n num_layers: int,\n norm=None\n ):\n super().__init__()\n\n self.layers = _get_clones(encoder_layer, num_layers)\n self.num_layers = num_layers\n self.norm = norm\n\n def forward(\n self,\n x: torch.Tensor,\n x_lens: torch.Tensor,\n ) -> torch.Tensor:\n\n mask = make_attn_mask(x_lens, self.layers[0].n_heads)\n\n for layer in self.layers:\n x = layer(x, mask=mask)\n if self.norm is not None:\n x = self.norm(x)\n return x" }, { "identifier": "TransformerEncoderLayer", "path": "modules/transformer.py", "snippet": "class TransformerEncoderLayer(nn.Module):\n def __init__(self, dim, ff_dim, conv_ff=False, n_heads=8, dropout=0.):\n super().__init__()\n\n self.dim = dim\n self.conv_ff = conv_ff\n self.n_heads = n_heads\n\n self.norm1 = nn.LayerNorm(dim)\n self.norm2 = nn.LayerNorm(dim)\n\n self.attn = MultiHeadAttention(dim, n_heads=n_heads, dropout=dropout)\n\n self.dropout = nn.Dropout(dropout)\n\n if conv_ff:\n self.ff = nn.Sequential(\n nn.Conv1d(dim, ff_dim, kernel_size=5, padding=2),\n nn.ReLU(),\n nn.Conv1d(ff_dim, dim, kernel_size=5, padding=2),\n )\n else:\n self.ff = nn.Sequential(\n nn.Linear(dim, ff_dim),\n nn.ReLU(),\n self.dropout,\n nn.Linear(ff_dim, dim),\n )\n\n def forward(\n self,\n x: torch.Tensor,\n mask: torch.Tensor = None\n ):\n\n x = x + self.attn(self.norm1(x), mask=mask)\n if self.conv_ff:\n x = self.norm2(x)\n x = rearrange(x, 'B T D -> B D T')\n x = x + self.ff(x)\n x = rearrange(x, 'B D T -> B T D')\n else:\n x = x + self.ff(self.norm2(x))\n return x" } ]

[ { "identifier": "ACI", "path": "torchcp/regression/predictors/aci.py", "snippet": "class ACI(SplitPredictor):\n \"\"\"\n Adaptive conformal inference (Gibbs et al., 2021)\n paper: https://arxiv.org/abs/2106.00170\n\n :param model: a pytorch model that can output the values of different quantiles.\n :param gamma: a step size parameter.\n \"\"\"\n\n def __init__(self, model, gamma):\n super().__init__(model)\n self.__gamma = gamma\n self.alpha_t = None\n\n def calculate_threshold(self, predicts, y_truth, alpha):\n if alpha >= 1 or alpha <= 0:\n raise ValueError(\"Significance level 'alpha' must be in (0,1).\")\n self.scores = torch.maximum(predicts[:, 0] - y_truth, y_truth - predicts[:, 1])\n self.alpha = alpha\n if self.alpha_t is None:\n self.alpha_t = alpha\n\n def predict(self, x, y_t=None, pred_interval_t=None):\n \"\"\"\n \n :param x: input features at the time t+1.\n :param y_t: the truth value at the time t.\n :param pred_interval_t: the prediction interval for the time t.\n \"\"\"\n self._model.eval()\n x = x.to(self._device)\n\n if y_t is None:\n err_t = self.alpha\n else:\n if len(y_t.shape) == 0:\n err_t = 1 if (y_t >= pred_interval_t[0]) & (y_t <= pred_interval_t[1]) else 0\n else:\n steps_t = len(y_t)\n w = torch.arange(steps_t).to(self._device)\n w = torch.pow(0.95, w)\n w = w / torch.sum(w)\n err = x.new_zeros(steps_t)\n for i in range(steps_t):\n err[i] = 1 if (y_t[i] >= pred_interval_t[i][0]) & (y_t[i] <= pred_interval_t[i][1]) else 0\n err_t = torch.sum(w * err)\n self.alpha_t = self.alpha_t + self.__gamma * (self.alpha - err_t)\n predicts_batch = self._model(x.to(self._device)).float()\n quantile = (1 - self.alpha_t) * (1 + 1 / self.scores.shape[0])\n if quantile > 1:\n quantile = 1\n q_hat = torch.quantile(self.scores, quantile)\n prediction_intervals = x.new_zeros(2)\n prediction_intervals[0] = predicts_batch[0] - q_hat\n prediction_intervals[1] = predicts_batch[1] + q_hat\n return prediction_intervals" }, { "identifier": "CQR", "path": "torchcp/regression/predictors/cqr.py", "snippet": "class CQR(SplitPredictor):\n \"\"\"\n Conformalized Quantile Regression (Romano et al., 2019)\n paper: https://arxiv.org/abs/1905.03222\n\n :param model: a pytorch model that can output alpha/2 and 1-alpha/2 quantile regression.\n \"\"\"\n\n def __init__(self, model):\n super().__init__(model)\n\n def calculate_threshold(self, predicts, y_truth, alpha):\n if alpha >= 1 or alpha <= 0:\n raise ValueError(\"Significance level 'alpha' must be in (0,1).\")\n self.scores = torch.maximum(predicts[:, 0] - y_truth, y_truth - predicts[:, 1])\n quantile = math.ceil((self.scores.shape[0] + 1) * (1 - alpha)) / self.scores.shape[0]\n if quantile > 1:\n quantile = 1\n self.q_hat = torch.quantile(self.scores, quantile)\n\n def predict(self, x_batch):\n self._model.eval()\n predicts_batch = self._model(x_batch.to(self._device)).float()\n if len(x_batch.shape) == 2:\n predicts_batch = self._model(x_batch.to(self._device)).float()\n prediction_intervals = x_batch.new_zeros((x_batch.shape[0], 2))\n prediction_intervals[:, 0] = predicts_batch[:, 0] - self.q_hat\n prediction_intervals[:, 1] = predicts_batch[:, 1] + self.q_hat\n else:\n prediction_intervals = torch.zeros(2)\n prediction_intervals[0] = predicts_batch[0] - self.q_hat\n prediction_intervals[1] = predicts_batch[1] + self.q_hat\n return prediction_intervals" }, { "identifier": "SplitPredictor", "path": "torchcp/regression/predictors/split.py", "snippet": "class SplitPredictor(object):\n \"\"\"\n Distribution-Free Predictive Inference For Regression (Lei et al., 2017)\n paper: https://arxiv.org/abs/1604.04173\n \n :param model: a pytorch model for regression.\n \"\"\"\n\n def __init__(self, model):\n self._model = model\n self._device = get_device(model)\n self._metric = Metrics()\n self.q_hat = None\n self.scores = None\n self.alpha = None\n\n def calibrate(self, cal_dataloader, alpha):\n self._model.eval()\n predicts_list = []\n y_truth_list = []\n with torch.no_grad():\n for examples in cal_dataloader:\n tmp_x, tmp_labels = examples[0].to(self._device), examples[1].to(self._device)\n tmp_predicts = self._model(tmp_x).detach()\n predicts_list.append(tmp_predicts)\n y_truth_list.append(tmp_labels)\n predicts = torch.cat(predicts_list).float().to(self._device)\n y_truth = torch.cat(y_truth_list).to(self._device)\n self.calculate_threshold(predicts, y_truth, alpha)\n\n def calculate_threshold(self, predicts, y_truth, alpha):\n if alpha >= 1 or alpha <= 0:\n raise ValueError(\"Significance level 'alpha' must be in (0,1).\")\n self.scores = torch.abs(predicts.reshape(-1) - y_truth)\n quantile = math.ceil((self.scores.shape[0] + 1) * (1 - alpha)) / self.scores.shape[0]\n if quantile > 1:\n quantile = 1\n self.q_hat = torch.quantile(self.scores, quantile)\n\n def predict(self, x_batch):\n self._model.eval()\n x_batch.to(self._device)\n with torch.no_grad():\n predicts_batch = self._model(x_batch).float().reshape(-1)\n prediction_intervals = x_batch.new_zeros((x_batch.shape[0], 2))\n prediction_intervals[:, 0] = predicts_batch - self.q_hat\n prediction_intervals[:, 1] = predicts_batch + self.q_hat\n\n return prediction_intervals\n\n def evaluate(self, data_loader):\n y_list = []\n predict_list = []\n with torch.no_grad():\n for examples in data_loader:\n tmp_x, tmp_y = examples[0].to(self._device), examples[1].to(self._device)\n tmp_prediction_intervals = self.predict(tmp_x)\n y_list.append(tmp_y)\n predict_list.append(tmp_prediction_intervals)\n\n predicts = torch.cat(predict_list).float().to(self._device)\n test_y = torch.cat(y_list).to(self._device)\n\n res_dict = {\"Coverage_rate\": self._metric('coverage_rate')(predicts, test_y),\n \"Average_size\": self._metric('average_size')(predicts)}\n return res_dict" }, { "identifier": "QuantileLoss", "path": "torchcp/regression/loss/quantile.py", "snippet": "class QuantileLoss(nn.Module):\n \"\"\"\n Pinball loss function (Romano et al., 2019).\n Paper: https://proceedings.neurips.cc/paper_files/paper/2019/file/5103c3584b063c431bd1268e9b5e76fb-Paper.pdf\n\n :param quantiles: a list of quantiles, such as :math: [alpha/2, 1-alpha/2].\n \"\"\"\n\n def __init__(self, quantiles):\n \"\"\"\n\n \"\"\"\n super().__init__()\n self.quantiles = quantiles\n\n def forward(self, preds, target):\n \"\"\" \n Compute the pinball loss.\n\n :param preds: the alpha/2 and 1-alpha/2 predictions of the model. The shape is batch x 2.\n :param target: the truth values. The shape is batch x 1.\n \"\"\"\n assert not target.requires_grad\n if preds.size(0) != target.size(0):\n raise IndexError(f\"Shape of preds must be equal to shape of target.\")\n losses = preds.new_zeros(len(self.quantiles))\n\n for i, q in enumerate(self.quantiles):\n errors = target - preds[:, i:i + 1]\n losses[i] = torch.sum(torch.max((q - 1) * errors, q * errors).squeeze(1))\n loss = torch.mean(losses)\n return loss" }, { "identifier": "Metrics", "path": "torchcp/regression/utils/metrics.py", "snippet": "class Metrics:\n def __call__(self, metric) -> Any:\n if metric not in METRICS_REGISTRY_REGRESSION.registered_names():\n raise NameError(f\"The metric: {metric} is not defined in TorchCP.\")\n return METRICS_REGISTRY_REGRESSION.get(metric)" }, { "identifier": "fix_randomness", "path": "torchcp/utils/common.py", "snippet": "def fix_randomness(seed=0):\n \"\"\"\n Fix the random seed for python, torch, numpy.\n\n :param seed: the random seed\n \"\"\"\n np.random.seed(seed=seed)\n torch.manual_seed(seed)\n torch.cuda.manual_seed(seed)\n random.seed(seed)" } ]

[ { "identifier": "get_used_characters_in_html", "path": "fontimize.py", "snippet": "def get_used_characters_in_html(html : str) -> set[chr]:\n soup = BeautifulSoup(html, 'html.parser')\n text = soup.get_text()\n return get_used_characters_in_str(text)" }, { "identifier": "charPair", "path": "fontimize.py", "snippet": "class charPair:\n def __init__(self, first : chr, second : chr):\n self.first = first\n self.second = second\n\n def __str__(self):\n return \"[\" + self.first + \"-\" + self.second + \"]\" # Pairs are inclusive\n \n # For print()-ing\n def __repr__(self):\n return self.__str__()\n \n def __eq__(self, other):\n if isinstance(other, charPair):\n return self.first == other.first and self.second == other.second\n return False\n \n def get_range(self):\n if self.first == self.second:\n return _get_unicode_string(self.first)\n else:\n return _get_unicode_string(self.first) + '-' + _get_unicode_string(self.second, False) # Eg \"U+0061-0071\"" }, { "identifier": "_get_char_ranges", "path": "fontimize.py", "snippet": "def _get_char_ranges(chars : list[chr]):\n chars.sort()\n if not chars:\n return []\n res : list[charPair] = []\n first : chr = chars[0]\n prev_seen : chr = first\n for c in chars[1:]:\n expected_next_char = chr(ord(prev_seen) + 1)\n if c != expected_next_char:\n # non-sequential, so time to start a new set\n pair = charPair(first, prev_seen)\n res.append(pair)\n first = c\n prev_seen = c\n # add final set if it hasn't been added yet\n if (not res) or (res[-1].second != prev_seen):\n pair = charPair(first, prev_seen)\n res.append(pair)\n\n return res" }, { "identifier": "optimise_fonts", "path": "fontimize.py", "snippet": "def optimise_fonts(text : str, fonts : list[str], fontpath : str = \"\", subsetname = \"FontimizeSubset\", verbose : bool = False, print_stats : bool = True) -> dict[str, typing.Any]:\n verbosity = 2 if verbose else 0 # ttf2web has 0, 1, 2, so match that to off and on\n\n res : dict[str, typing.Any] = {}\n res[\"css\"] = {} # at this level there are no CSS files, include just to prevent errors for API consumer\n\n characters = get_used_characters_in_str(text)\n\n char_list = list(characters)\n if verbosity >= 2:\n print(\"Characters:\")\n print(\" \" + str(char_list))\n res[\"chars\"] = characters # set of characters used in the input text\n\n char_ranges = _get_char_ranges(char_list)\n if verbosity >= 2:\n print(\"Character ranges:\")\n print(\" \" + str(char_ranges))\n \n uranges_str = ', '.join(r.get_range() for r in char_ranges)\n uranges = [[subsetname, uranges_str]] # subsetname here will be in the generated font, eg 'Arial.FontimizeSubset.woff2'\n if verbosity >= 2:\n print(\"Unicode ranges:\")\n print(\" \" + uranges_str) \n res[\"uranges\"] = uranges_str # list of unicode ranges matching the characters used in the input text\n\n # For each font, generate a new font file using only the used characters\n # By default, place it in the same folder as the respective font, unless fontpath is specified\n res[\"fonts\"] = {} # dict of old font path -> new font path\n for font in fonts:\n assetdir = fontpath if fontpath else path.dirname(font)\n t2w = TTF2Web(font, uranges, assetdir=assetdir)\n woff2_list = t2w.generateWoff2(verbosity=verbosity)\n # print(woff2_list)\n assert len(woff2_list) == 1 # We only expect one font file to be generated, per font input\n assert len(woff2_list[0]) == 2 # Pair of font, plus ranges -- we only care about [0], the font\n res[\"fonts\"][font] = woff2_list[0][0]\n\n if verbosity >= 2:\n print(\"Generated the following fonts from the originals:\")\n for k in res[\"fonts\"].keys():\n print(\" \" + k + \" ->\\n \" + res[\"fonts\"][k])\n\n if (verbosity >= 2) or print_stats:\n print(\"Results:\")\n print(\" Fonts processed: \" + str(len(res[\"fonts\"])))\n if (verbosity == 1): # If 2, printed above already\n print(\" Generated (use verbose output for input -> generated map):\")\n for k in res[\"fonts\"].keys():\n print(\" \" + res[\"fonts\"][k])\n sum_orig = _get_file_size_sum(list(res[\"fonts\"].keys()))\n sum_new = _get_file_size_sum(list(res[\"fonts\"].values())) \n print(\" Total original font size: \" + _file_size_to_readable(sum_orig))\n print(\" Total optimised font size: \" + _file_size_to_readable(sum_new))\n savings = sum_orig - sum_new;\n savings_percent = savings / sum_orig * 100 \n print(\" Savings: \" + _file_size_to_readable(savings) + \" less, which is \" + str(round(savings_percent, 1)) + \"%!\")\n print(\"Thankyou for using Fontimize!\") # A play on Font and Optimise, haha, so good pun clever. But seriously - hopefully a memorable name!\n\n return res" }, { "identifier": "optimise_fonts_for_files", "path": "fontimize.py", "snippet": "def optimise_fonts_for_files(files : list[str], font_output_dir = \"\", subsetname = \"FontimizeSubset\", verbose : bool = False, print_stats : bool = True, fonts : list[str] = [], addtl_text : str = \"\") -> dict[str, typing.Any]:\n if (len(files) == 0) and len(addtl_text) == 0: # If you specify any text, input files are optional -- note, not documented, used for cmd line app\n print(\"Error: No input files. Exiting.\")\n res = {\n \"css\" : [],\n \"fonts\" : [],\n \"chars\": set(),\n \"uranges\": []\n }\n \n text = addtl_text\n css_files : set[str] = set()\n font_files : set[str] = set()\n for f in fonts: # user-specified input font files\n font_files.add(f)\n\n for f in files:\n file_ext = pathlib.Path(f).suffix.lower()\n with open(f, 'r') as file:\n if file_ext == '.html' or file_ext == '.htm':\n html = file.read()\n soup = BeautifulSoup(html, 'html.parser')\n\n # Extract used text\n text += soup.get_text()\n\n # Extract CSS files the HTML references\n for link in soup.find_all('link', href=True):\n if 'css' in link['href']:\n css_ref = link['href']\n adjusted_css_path = _get_path(f, css_ref) # It'll be relative, so relative to the HTML file\n css_files.add(adjusted_css_path)\n else: # not HTML, treat as text\n text += file.read()\n\n # Sanity check that there is any text to process\n if len(text) == 0:\n print(\"Error: No text found in the input files or additional text. Exiting.\")\n res = {\n \"css\" : [],\n \"fonts\" : [],\n \"chars\": set(),\n \"uranges\": []\n }\n return res\n\n # Extract fonts from CSS files\n for css_file in css_files:\n with open(css_file, 'r') as file:\n css = file.read()\n\n # Extract the contents of all :before and :after CSS pseudo-elements; add these to the text\n pseudo_elements = _extract_pseudo_elements_content(css)\n for pe in pseudo_elements:\n text += pe\n\n # List of all fonts from @font-face src url: statements. This assumes they're all local files\n font_urls = _find_font_face_urls(css)\n for font_url in font_urls:\n # Only handle local files -- this does not support remote files\n adjusted_font_path = _get_path(adjusted_css_path, font_url) # Relative to the CSS file\n if path.isfile(adjusted_font_path):\n font_files.add(adjusted_font_path)\n else:\n # if verbose:\n print(\"Warning: Font file not found (may be remote not local?); skipping: \" + font_url + \" (resolved to \" + adjusted_font_path + \")\")\n\n if verbose:\n print(\"Found the following CSS files:\")\n for css_file in css_files:\n print(\" \" + css_file)\n\n print(\"Found the following fonts:\")\n for font_file in font_files:\n print(\" \" + font_file)\n\n # print(\"Found the following text:\")\n # print(text)\n \n if len(font_files) == 0:\n print(\"Error: No fonts found in the input files. Exiting.\")\n res = {\n \"css\" : css_files,\n \"fonts\" : [],\n \"chars\": set(),\n \"uranges\": []\n }\n return res\n\n res = optimise_fonts(text, font_files, fontpath=font_output_dir, subsetname=subsetname, verbose=verbose, print_stats=print_stats)\n res[\"css\"] = css_files\n return res;" } ]

[ { "identifier": "build_vision_tower", "path": "llava/model/multimodal_encoder/builder.py", "snippet": "def build_vision_tower(vision_tower_cfg, **kwargs):\n vision_tower = getattr(vision_tower_cfg, 'mm_vision_tower', getattr(vision_tower_cfg, 'vision_tower', None))\n is_absolute_path_exists = os.path.exists(vision_tower)\n if is_absolute_path_exists or vision_tower.startswith(\"openai\") or vision_tower.startswith(\"laion\"):\n return CLIPVisionTower(vision_tower, args=vision_tower_cfg, **kwargs)\n\n raise ValueError(f'Unknown vision tower: {vision_tower}')" }, { "identifier": "build_vision_projector", "path": "llava/model/multimodal_projector/builder.py", "snippet": "def build_vision_projector(config, delay_load=False, **kwargs):\n projector_type = getattr(config, 'mm_projector_type', 'linear')\n\n if projector_type == 'linear':\n return nn.Linear(config.mm_hidden_size, config.hidden_size)\n\n mlp_gelu_match = re.match(r'^mlp(\\d+)x_gelu$', projector_type)\n if mlp_gelu_match:\n mlp_depth = int(mlp_gelu_match.group(1))\n modules = [nn.Linear(config.mm_hidden_size, config.hidden_size)]\n for _ in range(1, mlp_depth):\n modules.append(nn.GELU())\n modules.append(nn.Linear(config.hidden_size, config.hidden_size))\n # import pdb;pdb.set_trace()\n return nn.Sequential(*modules)\n\n if projector_type == 'identity':\n return IdentityMap()\n\n raise ValueError(f'Unknown projector type: {projector_type}')" }, { "identifier": "IGNORE_INDEX", "path": "llava/constants.py", "snippet": "IGNORE_INDEX = -100" }, { "identifier": "IMAGE_TOKEN_INDEX", "path": "llava/constants.py", "snippet": "IMAGE_TOKEN_INDEX = -200" }, { "identifier": "DEFAULT_IMAGE_PATCH_TOKEN", "path": "llava/constants.py", "snippet": "DEFAULT_IMAGE_PATCH_TOKEN = \"<im_patch>\"" }, { "identifier": "DEFAULT_IM_START_TOKEN", "path": "llava/constants.py", "snippet": "DEFAULT_IM_START_TOKEN = \"<im_start>\"" }, { "identifier": "DEFAULT_IM_END_TOKEN", "path": "llava/constants.py", "snippet": "DEFAULT_IM_END_TOKEN = \"<im_end>\"" } ]

[ { "identifier": "ActivationFunction", "path": "layers/transformer/transformer.py", "snippet": "class TransformerEncoderLayer(torch.nn.Module):\nclass TransformerDecoderLayer(torch.nn.Module):\nclass TransformerDecoderBase(torch.nn.Module):\n class State:\nclass TransformerEncoder(torch.nn.Module):\nclass TransformerDecoder(TransformerDecoderBase):\nclass TransformerBase(torch.nn.Module):\nclass Transformer(TransformerBase):\n def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, activation: ActivationFunction = F.relu,\n attention_dropout=0):\n def forward(self, src: torch.Tensor, mask: Optional[AttentionMask] = None) -> torch.Tensor:\n def reset_parameters(self):\n def __init__(self, d_model, nhead, dim_feedforward=2048, dropout=0.1, activation: ActivationFunction = F.relu,\n attention_dropout=0):\n def forward(self, tgt: torch.Tensor, memory: torch.Tensor, tgt_mask: Optional[AttentionMask] = None,\n memory_key_padding_mask: Optional[torch.Tensor] = None,\n full_target: Optional[torch.Tensor] = None, pos_offset: int = 0) -> torch.Tensor:\n def reset_parameters(self):\n def __init__(self, d_model: int):\n def create_state(self, batch_size: int, max_length: int, device: torch.device) -> State:\n def one_step_forward(self, state: State, data: torch.Tensor, *args, **kwargs):\n def __init__(self, layer, n_layers: int, d_model, *args, **kwargs):\n def forward(self, data: torch.Tensor, *args, **kwargs):\n def __init__(self, layer, n_layers: int, d_model: int, *args, **kwargs):\n def forward(self, data: torch.Tensor, *args, **kwargs):\ndef TransformerEncoderWithLayer(layer: Type[torch.nn.Module] = TransformerEncoderLayer):\ndef TransformerDecoderWithLayer(layer: Type[torch.nn.Module] = TransformerDecoderLayer):\n def __init__(self, encoder: torch.nn.Module, decoder: torch.nn.Module):\n def forward(self, src: torch.Tensor, tgt: torch.Tensor, tgt_mask: Optional[torch.Tensor] = None,\n src_mask: Optional[AttentionMask] = None):\n def generate_square_subsequent_mask(sz: int, device: torch.device) -> torch.Tensor:\n def __init__(self, d_model: int = 512, nhead: int = 8, num_encoder_layers: int = 6, num_decoder_layers: int = 6,\n dim_feedforward: int = 2048, dropout: float = 0.1, activation: ActivationFunction = F.relu,\n encoder_layer=TransformerEncoderWithLayer(), decoder_layer=TransformerDecoderWithLayer(),\n attention_dropout: float = 0):" }, { "identifier": "FixedRelativeMultiheadAttention", "path": "layers/transformer/multi_head_relative_pos_attention.py", "snippet": "def shift(posmat: torch.Tensor) -> torch.Tensor:\n def __init__(self, state_size: int, n_heads: int, dropout: float, projection_size: Optional[int] = None):\n def get_attention_scores(self, mask: Optional[torch.Tensor],\n q_content: torch.Tensor, k_content: torch.Tensor,\n q_pos: torch.Tensor, k_pos: torch.Tensor,\n pos_offset: int, ar_gate: Optional[torch.Tensor] = None) -> torch.Tensor:\n def _attention(self, mask: Optional[torch.Tensor],\n q_content: torch.Tensor, k_content: torch.Tensor,\n q_pos: torch.Tensor, k_pos: torch.Tensor,\n v: torch.Tensor, pos_offset: int,\n ar_gate: Optional[torch.Tensor] = None) -> [torch.Tensor, torch.Tensor]:\n def _get_pos_subset(self, pos_encoding: torch.Tensor, length: int, offset: int) -> torch.Tensor:\n def plot(self, options: Dict[str, Any]) -> Dict[str, Any]:\n def __init__(self, state_size: int, n_heads: int, dropout: float = 0.0, input_size: Optional[int] = None,\n projection_size: Optional[int] = None, pos_clamp: Optional[int] = None,\n test_pos_clamp: Optional[int] = None):\n def _create_buffer(self, max_len: int, clamp: Optional[int] = None):\n def get_pos(self, l: int, offset: int) -> torch.Tensor:\n def __init__(self, state_size: int, n_heads: int, dropout: float = 0.0, global_pos_bias: bool = True,\n global_content_bias: bool = True, input_size: Optional[int] = None, absolute_gate: bool = False,\n projection_size: Optional[int] = None, output_size: Optional[int] = None, pos_clamp: Optional[int] = None,\n test_pos_clamp: Optional[int] = None):\n def add_head_specific_bias(self, data: torch.Tensor, bias: Optional[torch.Tensor]) -> torch.Tensor:\n def forward(self, curr_state: torch.Tensor, attend_to: torch.Tensor, mask: Optional[AttentionMask],\n pos_offset: Optional[int] = None, need_weights: bool = False):\n def reset_parameters(self):\nclass RelativeAttentionBase(MultiHeadAttentionBase):\nclass FixedRelativeMultiheadAttentionBase(RelativeAttentionBase):\nclass FixedRelativeMultiheadAttention(AttentionMergeMixin, FixedRelativeMultiheadAttentionBase):" }, { "identifier": "MultiHeadAttention", "path": "layers/transformer/multi_head_attention.py", "snippet": "class MultiHeadAttention(AttentionMergeMixin, AbsPosAttentionBase):\n def __init__(self, state_size: int, n_heads: int, dropout: float = 0.1, input_size: Optional[int] = None,\n out_size: Optional[int] = None):\n super(AbsPosAttentionBase, self).__init__(state_size, n_heads, dropout)\n\n self.data_to_kv = torch.nn.Linear(state_size, 2 * n_heads * self.projection_size, bias=False)\n self.data_to_q = torch.nn.Linear(input_size or state_size, n_heads * self.projection_size, bias=False)\n\n super(MultiHeadAttention, self).__init__(out_size)\n self.reset_parameters()\n\n def forward(self, curr_state: torch.Tensor, attend_to: torch.Tensor, mask: Optional[AttentionMask],\n need_weights: bool = False):\n # Input and output shape: [n_batch, n_steps, data_size]\n k, v = self.transform_data(attend_to, self.data_to_kv, 2)\n q, = self.transform_data(curr_state, self.data_to_q, 1)\n\n data, scores = self.merged_attention(curr_state.shape[0], q.shape[1], mask, q, k, v)\n if need_weights:\n return data, scores\n else:\n return data\n\n def reset_parameters(self):\n # super().reset_parameters()\n\n torch.nn.init.xavier_uniform_(self.data_to_q.weight)\n torch.nn.init.xavier_uniform_(self.data_to_kv.weight)\n torch.nn.init.xavier_uniform_(self.data_to_kv.weight)" }, { "identifier": "Transformer", "path": "layers/transformer/transformer.py", "snippet": "class Transformer(TransformerBase):\n def __init__(self, d_model: int = 512, nhead: int = 8, num_encoder_layers: int = 6, num_decoder_layers: int = 6,\n dim_feedforward: int = 2048, dropout: float = 0.1, activation: ActivationFunction = F.relu,\n encoder_layer=TransformerEncoderWithLayer(), decoder_layer=TransformerDecoderWithLayer(),\n attention_dropout: float = 0):\n\n super().__init__(\n encoder_layer(num_encoder_layers, d_model, nhead, dim_feedforward, dropout, activation, attention_dropout),\n decoder_layer(num_decoder_layers, d_model, nhead, dim_feedforward, dropout, activation, attention_dropout))" }, { "identifier": "TransformerEncoderWithLayer", "path": "layers/transformer/transformer.py", "snippet": "def TransformerEncoderWithLayer(layer: Type[torch.nn.Module] = TransformerEncoderLayer):\n return lambda *args, **kwargs: TransformerEncoder(layer, *args, **kwargs)" }, { "identifier": "TransformerDecoderWithLayer", "path": "layers/transformer/transformer.py", "snippet": "def TransformerDecoderWithLayer(layer: Type[torch.nn.Module] = TransformerDecoderLayer):\n return lambda *args, **kwargs: TransformerDecoder(layer, *args, **kwargs)" } ]

[ { "identifier": "MODEL_ENTRYPOINTS", "path": "src/mlx_llm/model/_registry.py", "snippet": "MODEL_ENTRYPOINTS = {\n \"Phi2\": phi2,\n \"LLaMA-2-7B-chat\": llama_2_7B_chat,\n \"TinyLlama-1.1B-Chat-v0.6\": tiny_llama_chat_v06,\n # \"Mistral-7B-Instruct-v0.1\": mistral_7B_instruct_v01,\n \"Mistral-7B-Instruct-v0.2\": mistral_7B_instruct_v02,\n \"OpenHermes-2.5-Mistral-7B\": openhermes_25_mistral_7B,\n \"e5-mistral-7b-instruct\": e5_mistral_7b_instruct\n}" }, { "identifier": "load_weights", "path": "src/mlx_llm/model/_utils.py", "snippet": "def load_weights(\n model: nn.Module,\n weights: str,\n strict: bool = True,\n verbose: bool = False\n) -> nn.Module:\n \"\"\"Load weights from a given path.\n\n Args:\n model (nn.Module): a LLM model\n weights (str): path to weights\n strict (bool, optional): whether to strictly enforce that the keys in weights match the keys of the model. Defaults to True.\n verbose (bool, optional): whether to print information during loading. Defaults to False.\n\n Returns:\n nn.Module: an nn.Module with loaded weights\n \"\"\"\n \n assert os.path.exists(weights), f\"Weights path {weights} does not exist.\"\n \n if verbose: print(f\"> Loading weights from {weights}\")\n \n weights = list(mx.load(weights).items())\n \n new_state = dict(weights)\n # create a torch-like state dict { layer_name: weights }\n model_state = dict(tree_flatten(model.parameters()))\n \n # check if new_state does not have more keys\n extras = set(new_state.keys()) - set(model_state.keys())\n if extras:\n extras = \" \".join(list(extras))\n if strict:\n raise ValueError(f\"Found extra keys in weights file: {extras}\")\n else:\n if verbose: print(f\"\\t- [WARNING] Found extra keys in weights file: {extras}\")\n \n # check if new_state does not have less keys\n missing = set(model_state.keys()) - set(new_state.keys())\n if missing:\n missing = \" \".join(list(missing))\n if strict:\n raise ValueError(f\"Missing keys in weights file: {missing}\")\n else:\n if verbose: print(f\"\\t- [WARNING] Missing keys in weights file: {missing}\")\n \n for k, w in model_state.items():\n try:\n new_w = new_state[k]\n except KeyError:\n if strict:\n raise ValueError(f\"Missing key {k} in weights file\")\n else:\n if verbose: print(f\"\\t- [WARNING] Missing key {k} in weights file\")\n continue\n \n # checking if new_w is an mx.array first\n if not isinstance(new_w, mx.array):\n if strict:\n raise ValueError(f\"Expected mx.array for key {k}, got {type(new_w)}\")\n else:\n if verbose: print(f\"\\t- [WARNING] Expected mx.array for key {k}, got {type(new_w)}\")\n # checking if new_w has the same shape as w\n if new_w.shape != w.shape:\n if strict:\n raise ValueError(f\"Expected shape {w.shape} for key {k}, got {new_w.shape}\")\n else:\n if verbose: print(f\"\\t- [WARNING] Expected shape {w.shape} for key {k}, got {new_w.shape}\")\n \n model.update(tree_unflatten(weights))\n \n return model" }, { "identifier": "load_weights_from_hf", "path": "src/mlx_llm/model/_utils.py", "snippet": "def load_weights_from_hf(\n model: nn.Module,\n model_name: str,\n strict: bool = True,\n verbose: bool = False\n) -> nn.Module:\n \"\"\"Load weights from HuggingFace Hub.\n\n Args:\n model (nn.Module): an LLM model\n model_name (str): model namw\n strict (bool, optional): whether to strictly enforce that the keys in weights match the keys of the model. Defaults to True.\n verbose (bool, optional): whether to print information during loading. Defaults to False.\n\n Returns:\n nn.Module: an LLM with loaded weights\n \"\"\"\n try:\n repo_id = MODEL_WEIGHTS[model_name][\"repo_id\"]\n filename = MODEL_WEIGHTS[model_name][\"filename\"]\n weights_path = hf_hub_download(repo_id=repo_id, repo_type=\"model\", filename=filename)\n except Exception as e:\n print(f\"Error while downloading weights from HuggingFace Hub: {e}. Weights won't be loaded.\")\n weights_path = None\n \n if weights_path is not None:\n model = load_weights(\n model=model,\n weights=weights_path,\n strict=strict,\n verbose=verbose\n )\n return model " } ]

[ { "identifier": "hash_anything", "path": "xetcache/util.py", "snippet": "def hash_anything(x):\n return hashlib.sha256(pickle.dumps(x)).hexdigest()" }, { "identifier": "probe_memo", "path": "xetcache/util.py", "snippet": "def probe_memo(memopath, inputhashstr, key=None):\n \"\"\"\n Locate the memo from the provided input.\n \"\"\"\n memo_file = inputhashstr + '.pickle'\n if key is None:\n full_memo_file = os.path.join(memopath, inputhashstr + '.pickle')\n else:\n key = str(key)\n full_memo_file = os.path.join(memopath, key, inputhashstr + '.pickle')\n if full_memo_file.startswith(\"xet://\"):\n try:\n openfile = fsspec.open(full_memo_file, 'rb')\n fbytestr = None\n with openfile as f:\n print(f\"Loading from {memo_file}\")\n # reading from a string first will avoid potential tiny\n # reads that are extraordinarily slow\n fbytestr = f.read()\n result = pickle.loads(fbytestr)\n return result\n except Exception as e:\n if str(\"404 Not Found\") in str(e):\n return None\n print(f'Failed to load: {e}')\n return None\n elif os.path.exists(full_memo_file):\n if file_is_pointer_file(full_memo_file):\n materialized = materialize_pointer_file(full_memo_file)\n else:\n materialized = True\n if materialized:\n with open(full_memo_file, 'rb') as f:\n print(f\"Loading from {memo_file}\")\n result = pickle.load(f)\n return result\n return None" }, { "identifier": "store_memo", "path": "xetcache/util.py", "snippet": "def store_memo(memopath, inputhashstr, store, key):\n \"\"\"\n Locate the memo from the provided input.\n \"\"\"\n memo_file = inputhashstr + '.pickle'\n if key is None:\n full_memo_file = os.path.join(memopath, inputhashstr + '.pickle')\n else:\n key = str(key)\n full_memo_file = os.path.join(memopath, key, inputhashstr + '.pickle')\n memopath = os.path.join(memopath, key)\n if full_memo_file.startswith(\"xet://\"):\n fs = fsspec.filesystem(\"xet\")\n with fs.transaction:\n openfile = fsspec.open(full_memo_file, 'wb')\n with openfile as f:\n print(f\"Writing to {memo_file}\")\n pickle.dump(store, f)\n else:\n os.makedirs(memopath, exist_ok=True)\n with open(full_memo_file, 'wb') as f:\n print(f\"Writing to {memo_file}\")\n pickle.dump(store, f)\n return None" }, { "identifier": "get_memo_path", "path": "xetcache/config.py", "snippet": "def get_memo_path():\n \"\"\"\n Reads the current memo path\n \"\"\"\n return _MEMOPATH" }, { "identifier": "get_runtime_threshold", "path": "xetcache/config.py", "snippet": "def get_runtime_threshold():\n \"\"\"\n Reads the current runtime threshold in seconds. \n Only functions or cells which run longer than this will be cached.\n \"\"\"\n return _RUNTIME_THRESHOLD_SEC" } ]