Datasets:

---

tianyang

/

repobench_python_v1.1

like 7

[ { "identifier": "CrossEntropyLabelSmooth", "path": "loss/softmax_loss.py", "snippet": "class CrossEntropyLabelSmooth(nn.Module):\n \"\"\"Cross entropy loss with label smoothing regularizer.\n\n Reference:\n Szegedy et al. Rethinking the Inception Architecture for Computer Vision. CVPR 2016.\n Equation: y = (1 - epsilon) * y + epsilon / K.\n\n Args:\n num_classes (int): number of classes.\n epsilon (float): weight.\n \"\"\"\n\n def __init__(self, num_classes, epsilon=0.1, use_gpu=True):\n super(CrossEntropyLabelSmooth, self).__init__()\n self.num_classes = num_classes\n self.epsilon = epsilon\n self.use_gpu = use_gpu\n self.logsoftmax = nn.LogSoftmax(dim=1)\n\n def forward(self, inputs, targets):\n \"\"\"\n Args:\n inputs: prediction matrix (before softmax) with shape (batch_size, num_classes)\n targets: ground truth labels with shape (num_classes)\n \"\"\"\n log_probs = self.logsoftmax(inputs) \n targets = torch.zeros(log_probs.size()).scatter_(1, targets.unsqueeze(1).data.cpu(), 1) \n if self.use_gpu: targets = targets.cuda()\n targets = (1 - self.epsilon) * targets + self.epsilon / self.num_classes\n loss = (- targets * log_probs).mean(0).sum()\n return loss" }, { "identifier": "LabelSmoothingCrossEntropy", "path": "loss/softmax_loss.py", "snippet": "class LabelSmoothingCrossEntropy(nn.Module):\n \"\"\"\n NLL loss with label smoothing.\n \"\"\"\n def __init__(self, smoothing=0.1):\n \"\"\"\n Constructor for the LabelSmoothing module.\n :param smoothing: label smoothing factor\n \"\"\"\n super(LabelSmoothingCrossEntropy, self).__init__()\n assert smoothing < 1.0\n self.smoothing = smoothing\n self.confidence = 1. - smoothing\n\n def forward(self, x, target):\n logprobs = F.log_softmax(x, dim=-1)\n nll_loss = -logprobs.gather(dim=-1, index=target.unsqueeze(1))\n nll_loss = nll_loss.squeeze(1)\n smooth_loss = -logprobs.mean(dim=-1)\n loss = self.confidence * nll_loss + self.smoothing * smooth_loss\n return loss.mean()" }, { "identifier": "TripletLoss", "path": "loss/triplet_loss.py", "snippet": "class TripletLoss(object):\n \"\"\"\n Triplet loss using HARDER example mining,\n modified based on original triplet loss using hard example mining\n \"\"\"\n\n def __init__(self, margin=None, hard_factor=0.0):\n self.margin = margin\n self.hard_factor = hard_factor\n if margin is not None:\n self.ranking_loss = nn.MarginRankingLoss(margin=margin)\n else:\n self.ranking_loss = nn.SoftMarginLoss()\n\n def __call__(self, global_feat, labels, normalize_feature=False):\n if normalize_feature:\n global_feat = normalize(global_feat, axis=-1)\n dist_mat = euclidean_dist(global_feat, global_feat) #B,B\n\n dist_ap, dist_an = hard_example_mining(dist_mat, labels) \n\n dist_ap *= (1.0 + self.hard_factor)\n dist_an *= (1.0 - self.hard_factor)\n\n y = dist_an.new().resize_as_(dist_an).fill_(1) \n if self.margin is not None:\n loss = self.ranking_loss(dist_an, dist_ap, y)\n else:\n loss = self.ranking_loss(dist_an - dist_ap, y)\n return loss, dist_ap, dist_an" }, { "identifier": "CenterLoss", "path": "loss/center_loss.py", "snippet": "class CenterLoss(nn.Module):\n \"\"\"Center loss.\n\n Reference:\n Wen et al. A Discriminative Feature Learning Approach for Deep Face Recognition. ECCV 2016.\n\n Args:\n num_classes (int): number of classes.\n feat_dim (int): feature dimension.\n \"\"\"\n\n def __init__(self, num_classes=751, feat_dim=2048, use_gpu=True):\n super(CenterLoss, self).__init__()\n self.num_classes = num_classes\n self.feat_dim = feat_dim\n self.use_gpu = use_gpu\n\n if self.use_gpu:\n self.centers = nn.Parameter(torch.randn(self.num_classes, self.feat_dim).cuda())\n else:\n self.centers = nn.Parameter(torch.randn(self.num_classes, self.feat_dim))\n\n def forward(self, x, labels):\n \"\"\"\n Args:\n x: feature matrix with shape (batch_size, feat_dim).\n labels: ground truth labels with shape (num_classes).\n \"\"\"\n assert x.size(0) == labels.size(0), \"features.size(0) is not equal to labels.size(0)\"\n\n batch_size = x.size(0)\n distmat = torch.pow(x, 2).sum(dim=1, keepdim=True).expand(batch_size, self.num_classes) + \\\n torch.pow(self.centers, 2).sum(dim=1, keepdim=True).expand(self.num_classes, batch_size).t()\n distmat.addmm_(1, -2, x, self.centers.t())\n\n classes = torch.arange(self.num_classes).long()\n if self.use_gpu: classes = classes.cuda()\n labels = labels.unsqueeze(1).expand(batch_size, self.num_classes)\n mask = labels.eq(classes.expand(batch_size, self.num_classes))\n\n dist = []\n for i in range(batch_size):\n value = distmat[i][mask[i]]\n value = value.clamp(min=1e-12, max=1e+12) # for numerical stability\n dist.append(value)\n dist = torch.cat(dist)\n loss = dist.mean()\n return loss" } ]

[ { "identifier": "CONFIG", "path": "aitviewer/configuration.py", "snippet": "CONFIG = Configuration()" }, { "identifier": "aa2rot_torch", "path": "aitviewer/utils/so3.py", "snippet": "def aa2rot_torch(rotation_vectors):\n \"\"\"\n Convert rotation vectors (angle-axis representation) to rotation matrices.\n :param rotation_vectors: A torch tensor of shape (..., 3).\n :return: A torch tensor of shape (..., 3, 3).\n \"\"\"\n assert isinstance(rotation_vectors, torch.Tensor)\n return roma.rotvec_to_rotmat(rotation_vectors)" }, { "identifier": "rot2aa_torch", "path": "aitviewer/utils/so3.py", "snippet": "def rot2aa_torch(rotation_matrices):\n \"\"\"\n Convert rotation matrices to rotation vectors (angle-axis representation).\n :param rotation_matrices: A torch tensor of shape (..., 3, 3).\n :return: A torch tensor of shape (..., 3).\n \"\"\"\n assert isinstance(rotation_matrices, torch.Tensor)\n return roma.rotmat_to_rotvec(rotation_matrices)" }, { "identifier": "compute_vertex_and_face_normals_torch", "path": "aitviewer/utils/utils.py", "snippet": "def compute_vertex_and_face_normals_torch(vertices, faces, vertex_faces, normalize=False):\r\n \"\"\"\r\n Compute (unnormalized) vertex normals for the given vertices.\r\n :param vertices: A tensor of shape (N, V, 3).\r\n :param faces: A tensor of shape (F, 3) indexing into `vertices`.\r\n :param vertex_faces: A tensor of shape (V, MAX_VERTEX_DEGREE) that lists the face IDs each vertex is a part of.\r\n :param normalize: Whether to make the normals unit length or not.\r\n :return: The vertex and face normals as tensors of shape (N, V, 3) and (N, F, 3) respectively.\r\n \"\"\"\r\n vs = vertices[:, faces.to(dtype=torch.long)]\r\n face_normals = torch.cross(vs[:, :, 1] - vs[:, :, 0], vs[:, :, 2] - vs[:, :, 0], dim=-1) # (N, F, 3)\r\n\r\n ns_all_faces = face_normals[:, vertex_faces] # (N, V, MAX_VERTEX_DEGREE, 3)\r\n ns_all_faces[:, vertex_faces == -1] = 0.0\r\n vertex_degrees = (vertex_faces > -1).sum(dim=-1).to(dtype=ns_all_faces.dtype)\r\n vertex_normals = ns_all_faces.sum(dim=-2) / vertex_degrees[None, :, None] # (N, V, 3)\r\n\r\n if normalize:\r\n face_normals = face_normals / torch.norm(face_normals, dim=-1).unsqueeze(-1)\r\n vertex_normals = vertex_normals / torch.norm(vertex_normals, dim=-1).unsqueeze(-1)\r\n\r\n return vertex_normals, face_normals\r" } ]

[ { "identifier": "ts_co_kurtosis", "path": "polars_ta/wq/time_series.py", "snippet": "def ts_co_kurtosis(x: Expr, y: Expr, d: int = 5, ddof: int = 0) -> Expr:\n return map_batches([x, y], lambda xx: batches_i2_o1([x1.to_numpy() for x1 in xx], roll_co_kurtosis, d))" }, { "identifier": "nb_roll_sum", "path": "polars_ta/utils/numba_.py", "snippet": "@jit(nopython=True, nogil=True, cache=True)\ndef nb_roll_sum(x1, window):\n \"\"\"演示代码，请直接用 pl.col('A').rolling_sum(10).alias('a1')\"\"\"\n out = np.full(x1.shape, np.nan, dtype=float)\n a1 = sliding_window_view(x1, window)\n for i, v1 in enumerate(a1):\n out[i + window - 1] = np.sum(v1)\n return out" }, { "identifier": "batches_i1_o1", "path": "polars_ta/utils/numba_.py", "snippet": "def batches_i1_o1(x1: np.ndarray, func, *args, dtype=None) -> Series:\n return Series(func(x1, *args), nan_to_null=True, dtype=dtype)" }, { "identifier": "roll_sum", "path": "polars_ta/utils/numba_.py", "snippet": "def roll_sum(x: Expr, n: int) -> Expr:\n return x.map_batches(lambda x1: batches_i1_o1(x1.to_numpy(), nb_roll_sum, n))" }, { "identifier": "roll_cov", "path": "polars_ta/utils/numba_.py", "snippet": "def roll_cov(a: Expr, b: Expr, n: int) -> Expr:\n return map_batches([a, b], lambda xx: batches_i2_o1([x1.to_numpy() for x1 in xx], nb_roll_cov, n))" } ]

[ { "identifier": "dense_nn", "path": "utils.py", "snippet": "def dense_nn(\n num_features,\n num_targets,\n num_layers,\n intermediate_size=10,\n activation=\"relu\",\n output_activation=\"sigmoid\",\n):\n if num_layers > 1:\n if intermediate_size is None:\n intermediate_size = max(num_features, num_targets)\n if activation == \"relu\":\n activation_fn = torch.nn.ReLU\n elif activation == \"sigmoid\":\n activation_fn = torch.nn.Sigmoid\n else:\n raise Exception(\"Invalid activation function: \" + str(activation))\n net_layers = [torch.nn.Linear(num_features, intermediate_size), activation_fn()]\n for _ in range(num_layers - 2):\n net_layers.append(torch.nn.Linear(intermediate_size, intermediate_size))\n net_layers.append(activation_fn())\n if not isinstance(num_targets, tuple):\n net_layers.append(torch.nn.Linear(intermediate_size, num_targets))\n else:\n net_layers.append(\n torch.nn.Linear(intermediate_size, reduce(operator.mul, num_targets, 1))\n )\n net_layers.append(View(num_targets))\n else:\n if not isinstance(num_targets, tuple):\n net_layers = [torch.nn.Linear(num_features, num_targets)]\n else:\n net_layers = [\n torch.nn.Linear(num_features, reduce(operator.mul, num_targets, 1)),\n View(num_targets),\n ]\n\n if output_activation == \"relu\":\n net_layers.append(torch.nn.ReLU())\n elif output_activation == \"sigmoid\":\n net_layers.append(torch.nn.Sigmoid())\n elif output_activation == \"tanh\":\n net_layers.append(torch.nn.Tanh())\n elif output_activation == \"softmax\":\n net_layers.append(torch.nn.Softmax(dim=-1))\n elif output_activation == \"elu\":\n net_layers.append(torch.nn.ELU())\n\n return torch.nn.Sequential(*net_layers)" }, { "identifier": "View", "path": "utils.py", "snippet": "class View(torch.nn.Module):\n def __init__(self, shape):\n super().__init__()\n self.shape = shape\n\n def __repr__(self):\n return f\"View{self.shape}\"\n\n def forward(self, input):\n \"\"\"\n Reshapes the input according to the shape saved in the view data structure.\n \"\"\"\n batch_size = input.shape[:-1]\n shape = (*batch_size, *self.shape)\n out = input.view(shape)\n return out" }, { "identifier": "Metric", "path": "metric.py", "snippet": "class Metric(nn.Module):\n def __init__(\n self,\n num_features,\n num_output,\n num_hidden,\n identity_init,\n identity_init_scale,\n ):\n super().__init__()\n self.base = nn.Sequential(\n nn.Linear(num_features, num_hidden),\n nn.ReLU(),\n nn.Linear(num_hidden, num_output * num_output),\n )\n self.identity_fac_log = torch.nn.parameter.Parameter(torch.zeros([]))\n if identity_init:\n last_layer = self.base[-1]\n last_layer.weight.data.div_(identity_init_scale)\n last_layer.bias.data = torch.eye(num_output).view(-1)\n\n self.num_output = num_output\n\n def forward(self, x):\n # A = torch.nn.functional.softplus(self.base(x))\n identity_fac = torch.exp(self.identity_fac_log)\n L = self.base(x)\n L = L.view(L.shape[0], self.num_output, self.num_output)\n A = (\n torch.bmm(L, L.transpose(1, 2))\n + identity_fac * torch.eye(self.num_output).repeat(x.shape[0], 1, 1).cuda()\n )\n # TODO: extend for PSD matrices with bounds from the\n # identity metric\n return A" } ]

[ { "identifier": "chunks", "path": "utils/itertools.py", "snippet": "def chunks(x, n):\n # return slices of lists\n if hasattr(x, '__len__'):\n for i in range(0, len(x), n):\n yield x[i:i+n]\n else:\n # return sub-generators of generators\n i = iter(x)\n for e in i:\n yield chain([e], islice(i, n-1))" }, { "identifier": "DiffusionProcessor", "path": "diffusion_processor.py", "snippet": "class DiffusionProcessor:\n def __init__(self, warmup=None, local_files_only=True):\n base_model = \"stabilityai/sdxl-turbo\"\n vae_model = \"madebyollin/taesdxl\"\n\n warnings.filterwarnings(\"ignore\", category=torch.jit.TracerWarning)\n\n disable_progress_bar()\n self.pipe = AutoPipelineForImage2Image.from_pretrained(\n base_model,\n torch_dtype=torch.float16,\n variant=\"fp16\",\n local_files_only=local_files_only,\n )\n\n self.pipe.vae = AutoencoderTiny.from_pretrained(\n vae_model, torch_dtype=torch.float16, local_files_only=local_files_only\n )\n fix_seed(self.pipe)\n\n print(\"Model loaded\")\n\n config = CompilationConfig.Default()\n config.enable_xformers = True\n config.enable_triton = True\n config.enable_cuda_graph = True\n self.pipe = compile(self.pipe, config=config)\n\n print(\"Model compiled\")\n\n self.pipe.to(device=\"cuda\", dtype=torch.float16)\n self.pipe.set_progress_bar_config(disable=True)\n\n print(\"Model moved to GPU\", flush=True)\n \n self.compel = Compel(\n tokenizer=[self.pipe.tokenizer, self.pipe.tokenizer_2],\n text_encoder=[self.pipe.text_encoder, self.pipe.text_encoder_2],\n returned_embeddings_type=ReturnedEmbeddingsType.PENULTIMATE_HIDDEN_STATES_NON_NORMALIZED,\n requires_pooled=[False, True],\n )\n self.prompt_cache = FixedSizeDict(32)\n print(\"Prepared compel\")\n\n self.generator = torch.manual_seed(0)\n \n if warmup:\n warmup_shape = [int(e) for e in warmup.split(\"x\")]\n images = np.zeros(warmup_shape, dtype=np.float32)\n for i in range(2):\n print(f\"Warmup {warmup} {i+1}/2\")\n start_time = time.time()\n self.run(\n images,\n prompt=\"warmup\",\n num_inference_steps=2,\n strength=1.0\n )\n print(\"Warmup finished\", flush=True)\n \n def embed_prompt(self, prompt):\n if prompt not in self.prompt_cache:\n with torch.no_grad():\n print(\"embedding prompt\", prompt)\n self.prompt_cache[prompt] = self.compel(prompt)\n return self.prompt_cache[prompt]\n \n def meta_embed_prompt(self, prompt):\n pattern = r'\\(\"(.*?)\"\\s*,\\s*\"(.*?)\"\\)\\.blend\\((.*?),(.*?)\\)'\n match = re.search(pattern, prompt)\n if not match:\n return self.embed_prompt(prompt)\n str1, str2, t1, t2 = match.groups()\n t1 = float(t1)\n t2 = float(t2)\n cond1, pool1 = self.embed_prompt(str1)\n cond2, pool2 = self.embed_prompt(str2)\n cond = cond1 * t1 + cond2 * t2\n pool = pool1 * t1 + pool2 * t2\n return cond, pool\n \n def run(self, images, prompt, num_inference_steps, strength, use_compel=False, seed=None):\n strength = min(max(1 / num_inference_steps, strength), 1)\n if seed is not None:\n self.generator = torch.manual_seed(seed)\n kwargs = {}\n if use_compel:\n conditioning, pooled = self.meta_embed_prompt(prompt)\n batch_size = len(images)\n conditioning_batch = conditioning.expand(batch_size, -1, -1)\n pooled_batch = pooled.expand(batch_size, -1)\n kwargs[\"prompt_embeds\"] = conditioning_batch\n kwargs[\"pooled_prompt_embeds\"] = pooled_batch\n else:\n kwargs[\"prompt\"] = [prompt] * len(images)\n return self.pipe(\n image=images,\n generator=self.generator,\n num_inference_steps=num_inference_steps,\n guidance_scale=0,\n strength=strength,\n output_type=\"np\",\n **kwargs\n ).images" } ]

[ { "identifier": "is_master", "path": "src/training/distributed.py", "snippet": "def is_master(args, local=False):\n return is_local_master(args) if local else is_global_master(args)" }, { "identifier": "zero_shot_eval", "path": "src/training/zero_shot.py", "snippet": "def zero_shot_eval(model, data, epoch, args):\n if 'val' not in data:\n return {}\n if args.zeroshot_frequency == 0:\n return {}\n if (epoch % args.zeroshot_frequency) != 0 and epoch != args.epochs:\n return {}\n logging.info('Region classifier')\n results = {}\n if args.test_type == \"coco_panoptic\":\n correct_rois, correct_crops, correct_maskpool, \\\n similarity_rois, similarity_crops, similarity_maskpool, \\\n all_box_sizes, all_is_thing, all_cls_labels = run_panoptic(model, data['val'].dataloader, args)\n results.update(macc_with_is_thing(correct_rois, all_is_thing, all_cls_labels, 'rois'))\n results.update(macc_with_is_thing(correct_crops, all_is_thing, all_cls_labels, 'crops'))\n results.update(macc_with_is_thing(correct_maskpool, all_is_thing, all_cls_labels, 'maskpool'))\n else:\n assert args.test_type == \"coco_detection\"\n correct_rois, correct_crops, all_box_sizes, all_cls_labels = run_det(model, data['val'].dataloader, args)\n results.update(macc_with_det(correct_rois, all_cls_labels, 'rois'))\n results.update(macc_with_det(correct_crops, all_cls_labels, 'crops'))\n\n return results" }, { "identifier": "get_autocast", "path": "src/training/precision.py", "snippet": "def get_autocast(precision):\n if precision == 'amp':\n return torch.cuda.amp.autocast\n elif precision == 'amp_bfloat16' or precision == 'amp_bf16':\n # amp_bfloat16 is more stable than amp float16 for clip training\n return lambda: torch.cuda.amp.autocast(dtype=torch.bfloat16)\n else:\n return suppress" } ]

[ { "identifier": "CONF_INTERVAL", "path": "custom_components/gasbuddy/const.py", "snippet": "CONF_INTERVAL = \"interval\"" }, { "identifier": "CONF_NAME", "path": "custom_components/gasbuddy/const.py", "snippet": "CONF_NAME = \"name\"" }, { "identifier": "CONF_POSTAL", "path": "custom_components/gasbuddy/const.py", "snippet": "CONF_POSTAL = \"zipcode\"" }, { "identifier": "CONF_STATION_ID", "path": "custom_components/gasbuddy/const.py", "snippet": "CONF_STATION_ID = \"station_id\"" }, { "identifier": "CONF_UOM", "path": "custom_components/gasbuddy/const.py", "snippet": "CONF_UOM = \"uom\"" }, { "identifier": "DEFAULT_NAME", "path": "custom_components/gasbuddy/const.py", "snippet": "DEFAULT_NAME = \"Gas Station\"" }, { "identifier": "DOMAIN", "path": "custom_components/gasbuddy/const.py", "snippet": "DOMAIN = \"gasbuddy\"" }, { "identifier": "CONFIG_DATA", "path": "tests/const.py", "snippet": "CONFIG_DATA = {\n CONF_NAME: \"Gas Station\",\n CONF_INTERVAL: 3600,\n CONF_STATION_ID: 208656,\n CONF_UOM: True,\n}" }, { "identifier": "STATION_LIST", "path": "tests/const.py", "snippet": "STATION_LIST = {\n \"187725\": \"Shell @ 1520 N Verrado Way\",\n \"208656\": \"Costco @ 1101 N Verrado Way\",\n \"87490\": \"Chevron @ 1419 N 195th Ave\",\n \"110402\": \"Circle K @ 721 N 195th Ave\",\n \"203982\": \"Fry's @ 19600 W Indian School Rd\",\n \"126744\": \"Circle K @ 537 S Watson Rd\",\n \"201250\": \"QuikTrip @ 900 S Watson Rd\",\n \"38363\": \"Fry's @ 1300 S Watson Rd\",\n \"27487\": \"Love's Travel Stop @ 1610 N Miller Rd\",\n \"160044\": \"QuikTrip @ 1850 S Miller Rd\",\n \"135437\": \"Chevron @ 2075 S Miller Rd\",\n \"130812\": \"Fry's @ 16380 W Yuma Rd\",\n \"200905\": \"Circle K @ 15535 W McDowell Rd\",\n \"85320\": \"Safeway @ 440 N Estrella Pkwy\",\n \"155795\": \"QuikTrip @ 575 N Estrella Pkwy\",\n \"118417\": \"Circle K @ 307 E US-85\",\n \"154238\": \"Chevron @ 825 E Monroe Ave\",\n \"150938\": \"Shell @ 501 E Monroe Ave\",\n \"209199\": \"QuikTrip @ 1540 N Bullard Ave\",\n \"27442\": \"Safeway @ 14175 W Indian School Rd\",\n}" } ]

[ { "identifier": "update_actor", "path": "actor.py", "snippet": "def update_actor(\n key: PRNGKey,\n actor: Model,\n critic: Model,\n value: Model,\n batch: Batch,\n alpha: float,\n epsilon: float,\n alg: str,\n) -> Tuple[Model, InfoDict]:\n v = value(batch.observations)\n if alg == \"PORelDICE\":\n q1, q2 = critic(batch.observations, batch.actions)\n q = jnp.minimum(q1, q2)\n weight = 1 + (q - v) / alpha\n weight = jnp.maximum(weight, 0.0)\n else:\n NotImplementedError\n\n weight = jnp.clip(weight, 0.0, 100.0)\n\n def actor_loss_fn(actor_params: Params) -> Tuple[jnp.ndarray, InfoDict]:\n dist = actor.apply(\n {\"params\": actor_params},\n batch.observations,\n training=True,\n rngs={\"dropout\": key},\n )\n log_probs = dist.log_prob(batch.actions)\n actor_loss = -(weight * log_probs).mean()\n return actor_loss, {\"actor_loss\": actor_loss}\n\n new_actor, info = actor.apply_gradient(actor_loss_fn)\n\n return new_actor, info" }, { "identifier": "Batch", "path": "common.py", "snippet": "def default_init(scale: Optional[float] = jnp.sqrt(2)):\n def __call__(self, x: jnp.ndarray, training: bool = False) -> jnp.ndarray:\n def create(\n cls,\n model_def: nn.Module,\n inputs: Sequence[jnp.ndarray],\n tx: Optional[optax.GradientTransformation] = None,\n ) -> \"Model\":\n def __call__(self, *args, **kwargs):\n def apply(self, *args, **kwargs):\n def apply_gradient(self, loss_fn) -> Tuple[Any, \"Model\"]:\n def save(self, save_path: str):\n def load(self, load_path: str) -> \"Model\":\nclass MLP(nn.Module):\nclass Model:" }, { "identifier": "update_q", "path": "critic.py", "snippet": "def update_q(\n critic: Model, value: Model, batch: Batch, discount: float, alg: str\n) -> Tuple[Model, InfoDict]:\n next_v = value(batch.next_observations)\n target_q = batch.rewards + discount * batch.masks * next_v\n def critic_loss_fn(critic_params: Params) -> Tuple[jnp.ndarray, InfoDict]:\n q1, q2 = critic.apply(\n {\"params\": critic_params}, batch.observations, batch.actions\n )\n\n critic_loss = ((q1 - target_q) ** 2 + (q2 - target_q) ** 2).mean()\n \n return critic_loss, {\n \"critic_loss\": critic_loss,\n \"q1\": q1.mean(),\n }\n\n new_critic, info = critic.apply_gradient(critic_loss_fn)\n\n return new_critic, info" }, { "identifier": "update_v", "path": "critic.py", "snippet": "def update_v(\n critic: Model, value: Model, batch: Batch, alpha: float, epsilon:float, discount: float, alg: str\n) -> Tuple[Model, InfoDict]:\n def value_loss_fn(value_params: Params) -> Tuple[jnp.ndarray, InfoDict]:\n v = value.apply({\"params\": value_params}, batch.observations)\n v_0 = value.apply({\"params\": value_params}, batch.initial_observations)\n q1, q2 = critic(batch.observations, batch.actions)\n q = jnp.minimum(q1, q2)\n \n if alg == \"PORelDICE\":\n sp_term = (q-v) / alpha\n value_loss = ((1-discount) * v_0).mean() + (alpha * \n jnp.where(1 + sp_term > epsilon, \n (0.5 * sp_term **2 + sp_term),\n (epsilon) * (sp_term - epsilon + 1) + 0.5 * (epsilon - 1) ** 2 + epsilon - 1\n )).mean()\n else:\n raise NotImplementedError(\"please choose PORelDICE\")\n return value_loss, {\n \"value_loss\": value_loss,\n \"v\": v.mean(),\n \"q-v\": (q - v).mean(),\n }\n\n new_value, info = value.apply_gradient(value_loss_fn)\n\n return new_value, info" } ]

[ { "identifier": "MouseInstruct", "path": "mouse_instruct.py", "snippet": "class MouseInstruct:\n def __init__(self, dev):\n self._buttons_mask = 0\n self._dev = dev\n self.move(0, 0)\n\n @classmethod\n def getMouse(cls, vid=0, pid=0, ping_code=0xf9):\n dev = find_mouse_device(vid, pid, ping_code)\n if not dev:\n vid_str = hex(vid) if vid else \"Unspecified\"\n pid_str = hex(pid) if pid else \"Unspecified\"\n ping_code_str = hex(ping_code) if pid else \"Unspecified\"\n error_msg = (\"[-] Device \"\n f\"Vendor ID: {vid_str}, Product ID: {pid_str} \"\n f\"Pingcode: {ping_code_str} not found!\")\n raise DeviceNotFoundError(error_msg)\n return cls(dev)\n\n def _buttons(self, buttons):\n if buttons != self._buttons_mask:\n self._buttons_mask = buttons\n self.move(0, 0)\n\n def click(self, button = MOUSE_LEFT):\n self._buttons_mask = button\n self.move(0, 0)\n self._buttons_mask = 0\n self.move(0, 0)\n\n def press(self, button = MOUSE_LEFT):\n self._buttons(self._buttons_mask | button)\n\n def release(self, button = MOUSE_LEFT):\n self._buttons(self._buttons_mask & ~button)\n\n def is_pressed(self, button = MOUSE_LEFT):\n return bool(button & self._buttons_mask)\n\n def move(self, x, y):\n limited_x = limit_xy(x)\n limited_y = limit_xy(y)\n self._sendRawReport(self._makeReport(limited_x, limited_y))\n\n def _makeReport(self, x, y):\n report_data = [\n 0x01, # Report ID: 0\n self._buttons_mask,\n low_byte(x), high_byte(x),\n low_byte(y), high_byte(y)\n ]\n return report_data\n\n\n def _sendRawReport(self, report_data):\n self._dev.write(report_data)" }, { "identifier": "DeviceNotFoundError", "path": "mouse_instruct.py", "snippet": "class DeviceNotFoundError(Exception):\n pass" } ]

[ { "identifier": "download_image", "path": "image_downloader.py", "snippet": "def download_image(image_url, local_path, job_id, prompt, additional_metadata):\r\n logging.info(f\"Initiating download: URL {image_url}, Local Path {local_path}, Job ID {job_id}, Prompt {prompt[:30]}...\")\r\n\r\n try:\r\n response = requests.get(image_url, stream=True)\r\n response.raise_for_status()\r\n\r\n # Read image from response\r\n image_data = response.content\r\n image = Image.open(BytesIO(image_data))\r\n\r\n # Draw text on the image\r\n draw = ImageDraw.Draw(image)\r\n font = ImageFont.load_default(size=28) # Specifying font size\r\n text = prompt.split(',')[0] # Extract first part of the prompt\r\n\r\n # Positioning the text at top left (10, 10)\r\n # draw.text((20, 10), text, font=font)\r\n\r\n # Prepare metadata (EXIF) with additional fields\r\n exif_dict = {\r\n \"0th\": {},\r\n \"Exif\": {},\r\n \"1st\": {},\r\n \"thumbnail\": None,\r\n \"GPS\": {} # Optional, if you want to include GPS-related tags\r\n }\r\n exif_dict[\"0th\"][piexif.ImageIFD.Artist] = job_id\r\n exif_dict[\"0th\"][piexif.ImageIFD.ImageDescription] = prompt\r\n\r\n # Concatenate additional metadata into a single string\r\n user_comment = \"; \".join([f\"{key}: {value}\" for key, value in additional_metadata.items()])\r\n\r\n # Encode user comment with ASCII prefix\r\n encoded_comment = b\"ASCII\\x00\\x00\" + user_comment.encode(\"utf-8\")\r\n\r\n # Assign encoded user comment to EXIF\r\n exif_dict[\"Exif\"][piexif.ExifIFD.UserComment] = encoded_comment\r\n\r\n # Generate EXIF bytes\r\n exif_bytes = piexif.dump(exif_dict)\r\n\r\n # Save image with metadata and added text\r\n image.save(local_path, \"jpeg\", exif=exif_bytes)\r\n logging.info(f\"Image downloaded successfully and saved to {local_path}, with embedded text and metadata\")\r\n\r\n except requests.exceptions.HTTPError as e:\r\n logging.error(f\"HTTP error occurred while downloading the image: {e.response.status_code} - {e.response.text}\")\r\n except requests.exceptions.ConnectionError as e:\r\n logging.error(\"Connection error occurred while downloading the image.\")\r\n except requests.exceptions.Timeout as e:\r\n logging.error(\"Timeout error occurred while downloading the image.\")\r\n except requests.exceptions.RequestException as e:\r\n logging.error(f\"An error occurred while downloading the image: {e}\")\r\n except IOError as e:\r\n logging.error(f\"I/O error occurred while saving the image to {local_path}: {e}\")\r\n except Exception as e:\r\n logging.error(f\"An unexpected error occurred while downloading the image: {e}\")\r" }, { "identifier": "MAX_CONCURRENT_JOBS", "path": "config.py", "snippet": "MAX_CONCURRENT_JOBS = 1\r" }, { "identifier": "RATE_LIMIT_DELAY", "path": "config.py", "snippet": "RATE_LIMIT_DELAY = timedelta(seconds=2)\r" }, { "identifier": "API_BASE_URL", "path": "config.py", "snippet": "API_BASE_URL = 'https://cloud.leonardo.ai/api/rest/v1/'\r" }, { "identifier": "HEADERS", "path": "config.py", "snippet": "HEADERS = {\r\n \"accept\": \"application/json\",\r\n \"authorization\": AUTHORIZATION_TOKEN\r\n}" }, { "identifier": "API_CALL_DELAY", "path": "config.py", "snippet": "API_CALL_DELAY = 3\r" }, { "identifier": "get_job_data", "path": "job_data_store.py", "snippet": "def get_job_data(job_id):\r\n global job_data_store\r\n data = job_data_store.get(job_id)\r\n if data:\r\n logging.info(f\"Retrieved job data for ID {job_id}: {data}\")\r\n else:\r\n logging.warning(f\"No job data found for ID {job_id}\")\r\n return data\r" }, { "identifier": "store_job_data", "path": "job_data_store.py", "snippet": "def store_job_data(job_id, prompt):\r\n global job_data_store\r\n job_data_store[job_id] = {\r\n \"prompt\": prompt\r\n }\r\n # logging.info(f\"Job data stored: ID {job_id}, Prompt {prompt[:30]}...\")\r\n\r\n # Log the current state of the job_data_store\r\n # logging.info(f\"Current state of job_data_store: {job_data_store}\")\r" } ]

[ { "identifier": "ChatHistoryManager", "path": "chat.py", "snippet": "class ChatHistoryManager:\n def __init__(self, filename=\"chat_history.txt\", max_file_size_mb=5):\n self.history = []\n self.filename = filename\n self.max_file_size_mb = max_file_size_mb\n\n def add_message(self, role, text):\n timestamp = datetime.now().strftime(\"%Y-%m-%d %H:%M:%S\")\n self.history.append(\n {'role': role, 'text': text, 'timestamp': timestamp})\n\n def save_to_file(self):\n self._rotate_file_if_needed()\n with open(self.filename, \"a\", encoding=\"utf-8\") as file:\n for message in self.history:\n file.write(\n f\"{message['timestamp']} {message['role']}: {message['text']}\\n\")\n self.history.clear()\n\n def display(self):\n for message in self.history:\n print(\n f\"{message['timestamp']} {message['role']}: {message['text']}\")\n\n def _rotate_file_if_needed(self):\n if not os.path.exists(self.filename):\n with open(self.filename, \"a\", encoding=\"utf-8\") as file:\n pass\n\n if os.path.getsize(self.filename) > self.max_file_size_mb * 1024 * 1024:\n os.rename(self.filename, self.filename + \".backup\")" }, { "identifier": "main", "path": "chat.py", "snippet": "def main():\n load_dotenv()\n api_key = os.getenv(\"GEMINI_API_KEY\")\n if not api_key:\n raise ValueError(\n \"API key not found. Please set your GEMINI_API_KEY in the environment.\")\n\n genai.configure(api_key=api_key)\n\n generation_config = {\n \"temperature\": 0.7,\n \"top_p\": 1,\n \"top_k\": 1,\n \"max_output_tokens\": 2048,\n }\n\n safety_settings = {\n \"HARM_CATEGORY_HARASSMENT\": \"BLOCK_NONE\",\n \"HARM_CATEGORY_HATE_SPEECH\": \"BLOCK_NONE\",\n \"HARM_CATEGORY_SEXUALLY_EXPLICIT\": \"BLOCK_NONE\",\n \"HARM_CATEGORY_DANGEROUS_CONTENT\": \"BLOCK_NONE\",\n }\n\n history_manager = ChatHistoryManager()\n history_manager.add_message(\"system\", \"--- New Session ---\")\n\n model = genai.GenerativeModel(\n 'gemini-pro', generation_config=generation_config, safety_settings=safety_settings)\n chat = model.start_chat(history=[])\n\n while True:\n user_input = input(\"User: \").strip()\n if not user_input:\n print(\"Please enter some text.\")\n continue\n\n if user_input.lower() == \"history\":\n history_manager.display()\n continue\n\n if user_input.lower() == \"restart\":\n history_manager.save_to_file()\n os.system('cls' if os.name == 'nt' else 'clear')\n history_manager.add_message(\"system\", \"--- New Session ---\")\n chat = model.start_chat(history=[])\n continue\n\n if user_input.lower() == \"exit\":\n history_manager.save_to_file()\n break\n\n try:\n response = chat.send_message(user_input, stream=True)\n response_text = \"\"\n for chunk in response:\n if chunk.text.endswith(\".\"):\n response_text += chunk.text\n else:\n response_text += re.sub(r'\\s*$', '.', chunk.text)\n print(chunk.text)\n\n history_manager.add_message(\"user\", user_input)\n history_manager.add_message(\"gemini\", response_text)\n except Exception as e:\n print(f\"An error occurred: {e}\")" } ]

[ { "identifier": "Config", "path": "config/config.py", "snippet": "class Config(object):\n r\"\"\"\n A collection of all the required configuration parameters. This class is a nested dict-like\n structure, with nested keys accessible as attributes. It contains sensible default values for\n all the parameters, which may be overriden by (first) through a YAML file and (second) through\n a list of attributes and values.\n\n Extended Summary\n ----------------\n This class definition contains default values corresponding to ``joint_training`` phase, as it\n is the final training phase and uses almost all the configuration parameters. Modification of\n any parameter after instantiating this class is not possible, so you must override required\n parameter values in either through ``config_yaml`` file or ``config_override`` list.\n\n Parameters\n ----------\n config_yaml: str\n Path to a YAML file containing configuration parameters to override.\n config_override: List[Any], optional (default= [])\n A list of sequential attributes and values of parameters to override. This happens after\n overriding from YAML file.\n\n Examples\n --------\n Let a YAML file named \"config.yaml\" specify these parameters to override::\n\n ALPHA: 1000.0\n BETA: 0.5\n\n >>> _C = Config(\"config.yaml\", [\"OPTIM.BATCH_SIZE\", 2048, \"BETA\", 0.7])\n >>> _C.ALPHA # default: 100.0\n 1000.0\n >>> _C.BATCH_SIZE # default: 256\n 2048\n >>> _C.BETA # default: 0.1\n 0.7\n\n Attributes\n ----------\n \"\"\"\n\n def __init__(self, config_yaml: str, config_override: List[Any] = []):\n self._C = CN()\n self._C.GPU = [0]\n self._C.VERBOSE = False\n\n self._C.MODEL = CN()\n self._C.MODEL.SESSION = 'MRI-CT'\n self._C.MODEL.INPUT = 'MRI'\n self._C.MODEL.TARGET = 'CT'\n\n self._C.OPTIM = CN()\n self._C.OPTIM.BATCH_SIZE = 1\n self._C.OPTIM.SEED = 3407\n self._C.OPTIM.NUM_EPOCHS = 200\n self._C.OPTIM.NEPOCH_DECAY = [100]\n self._C.OPTIM.LR_INITIAL = 0.0002\n self._C.OPTIM.LR_MIN = 0.0002\n self._C.OPTIM.BETA1 = 0.5\n self._C.OPTIM.WANDB = False\n\n self._C.TRAINING = CN()\n self._C.TRAINING.VAL_AFTER_EVERY = 1\n self._C.TRAINING.RESUME = False\n self._C.TRAINING.TRAIN_DIR = '../dataset/MRI-CT/train'\n self._C.TRAINING.VAL_DIR = '../dataset/MRI-CT/test'\n self._C.TRAINING.SAVE_DIR = 'checkpoints'\n self._C.TRAINING.PS_W = 256\n self._C.TRAINING.PS_H = 256\n self._C.TRAINING.ORI = False\n\n self._C.TESTING = CN()\n self._C.TESTING.WEIGHT = './checkpoints/MRI-PET_epoch_68.pth'\n self._C.TESTING.SAVE_IMAGES = False\n\n # Override parameter values from YAML file first, then from override list.\n self._C.merge_from_file(config_yaml)\n self._C.merge_from_list(config_override)\n\n # Make an instantiated object of this class immutable.\n self._C.freeze()\n\n def dump(self, file_path: str):\n r\"\"\"Save config at the specified file path.\n\n Parameters\n ----------\n file_path: str\n (YAML) path to save config at.\n \"\"\"\n self._C.dump(stream=open(file_path, \"w\"))\n\n def __getattr__(self, attr: str):\n return self._C.__getattr__(attr)\n\n def __repr__(self):\n return self._C.__repr__()" }, { "identifier": "get_training_data", "path": "data/data_RGB.py", "snippet": "def get_training_data(rgb_dir, inp, target, img_options):\n assert os.path.exists(rgb_dir)\n return DataLoaderTrain(rgb_dir, inp, target, img_options)" }, { "identifier": "get_validation_data", "path": "data/data_RGB.py", "snippet": "def get_validation_data(rgb_dir, inp, target, img_options):\n assert os.path.exists(rgb_dir)\n return DataLoaderVal(rgb_dir, inp, target, img_options)" } ]

[ { "identifier": "tqdm", "path": "third-party/tqdm-4.66.1/tqdm/auto.py", "snippet": "class tqdm(notebook_tqdm, asyncio_tqdm): # pylint: disable=inconsistent-mro\n pass" }, { "identifier": "TqdmWarning", "path": "third-party/tqdm-4.66.1/tqdm/std.py", "snippet": "class TqdmWarning(Warning):\n \"\"\"base class for all tqdm warnings.\n\n Used for non-external-code-breaking errors, such as garbled printing.\n \"\"\"\n def __init__(self, msg, fp_write=None, *a, **k):\n if fp_write is not None:\n fp_write(\"\\n\" + self.__class__.__name__ + \": \" + str(msg).rstrip() + '\\n')\n else:\n super(TqdmWarning, self).__init__(msg, *a, **k)" }, { "identifier": "MonoWorker", "path": "third-party/tqdm-4.66.1/tqdm/contrib/utils_worker.py", "snippet": "class MonoWorker(object):\n \"\"\"\n Supports one running task and one waiting task.\n The waiting task is the most recent submitted (others are discarded).\n \"\"\"\n def __init__(self):\n self.pool = ThreadPoolExecutor(max_workers=1)\n self.futures = deque([], 2)\n\n def submit(self, func, *args, **kwargs):\n \"\"\"`func(*args, **kwargs)` may replace currently waiting task.\"\"\"\n futures = self.futures\n if len(futures) == futures.maxlen:\n running = futures.popleft()\n if not running.done():\n if len(futures): # clear waiting\n waiting = futures.pop()\n waiting.cancel()\n futures.appendleft(running) # re-insert running\n try:\n waiting = self.pool.submit(func, *args, **kwargs)\n except Exception as e:\n tqdm_auto.write(str(e))\n else:\n futures.append(waiting)\n return waiting" } ]

[ { "identifier": "LogicCommandManager", "path": "Heart/Logic/LogicCommandManager.py", "snippet": "class LogicCommandManager:\n commandsList = {\n 201: ChangeAvatarNameCommand,\n 202: 'DiamondsAddedCommand',\n 203: 'GiveDeliveryItemsCommand',\n 204: 'DayChangedCommand',\n 205: 'DecreaseHeroScoreCommand',\n 206: 'AddNotificationCommand',\n 207: 'ChangeResourcesCommand',\n 208: 'TransactionsRevokedCommand',\n 209: 'KeyPoolChangedCommand',\n 210: 'IAPChangedCommand',\n 211: 'OffersChangedCommand',\n 212: 'PlayerDataChangedCommand',\n 213: 'InviteBlockingChangedCommand',\n 214: 'GemNameChangeStateChangedCommand',\n 215: 'SetSupportedCreatorCommand',\n 216: 'CooldownExpiredCommand',\n 217: 'ProLeagueSeasonChangedCommand',\n 218: 'BrawlPassSeasonChangedCommand',\n 219: 'BrawlPassUnlockedCommand',\n 220: 'HerowinQuestsChangedCommand',\n 221: 'TeamChatMuteStateChangedCommand',\n 222: 'RankedSeasonChangedCommand',\n 223: 'CooldownAddedCommand',\n 224: 'SetESportsHubNotificationCommand',\n 228: 'RefreshRandomRewardsCommand',\n 500: 'GatchaCommand',\n 503: 'ClaimDailyRewardCommand',\n 504: 'SendAllianceMailCommand',\n 505: SetPlayerThumbnailCommand,\n 506: 'SelectSkinCommand',\n 507: 'UnlockSkinCommand',\n 508: 'ChangeControlModeCommand',\n 509: 'PurchaseDoubleCoinsCommand',\n 511: 'HelpOpenedCommand',\n 512: 'ToggleInGameHintsCommand',\n 514: 'DeleteNotificationCommand',\n 515: 'ClearShopTickersCommand',\n 517: 'ClaimRankUpRewardCommand',\n 518: 'PurchaseTicketsCommand',\n 519: PurchaseOfferCommand,\n 520: 'LevelUpCommand',\n 521: 'PurchaseHeroLvlUpMaterialCommand',\n 522: 'HeroSeenCommand',\n 523: 'ClaimAdRewardCommand',\n 524: 'VideoStartedCommand',\n 525: 'SelectCharacterCommand',\n 526: 'UnlockFreeSkinsCommand',\n 527: SetPlayerNameColorCommand,\n 528: 'ViewInboxNotificationCommand',\n 529: 'SelectStarPowerCommand',\n 530: 'SetPlayerAgeCommand',\n 531: 'CancelPurchaseOfferCommand',\n 532: 'ItemSeenCommand',\n 533: 'QuestSeenCommand',\n 534: 'PurchaseBrawlPassCommand',\n 535: 'ClaimTailRewardCommand',\n 536: 'PurchaseBrawlpassProgressCommand',\n 537: 'VanityItemSeenCommand',\n 538: 'SelectEmoteCommand',\n 539: 'BrawlPassAutoCollectWarningSeenCommand',\n 540: 'PurchaseChallengeLivesCommand',\n 541: 'ClearESportsHubNotificationCommand',\n 542: 'SelectGroupSkinCommand',\n 571: 'OpenRandomCommand'\n }\n\n def getCommandsName(commandType):\n try:\n command = LogicCommandManager.commandsList[commandType]\n except KeyError:\n command = str(commandType)\n if type(command) == str:\n return command\n else:\n return command.__name__\n\n def commandExist(commandType):\n return (commandType in LogicCommandManager.commandsList.keys())\n\n def createCommand(commandType, commandPayload=b''):\n commandList = LogicCommandManager.commandsList\n if LogicCommandManager.commandExist(commandType):\n print(LogicCommandManager.getCommandsName(commandType), \"created\")\n if type(commandList[commandType]) == str:\n pass\n else:\n return commandList[commandType](commandPayload)\n else:\n print(commandType, \"skipped\")\n return None\n\n def isServerToClient(commandType):\n if 200 <= commandType < 500:\n return True\n elif 500 <= commandType:\n return False" }, { "identifier": "PiranhaMessage", "path": "Heart/Packets/PiranhaMessage.py", "snippet": "class PiranhaMessage(ByteStream):\n def __init__(self, messageData):\n super().__init__(messageData)\n self.messageBuffer = messageData\n self.fields = {}\n\n def decode(self, fields):\n if True:\n print()\n for typeName,value in fields.items():\n print(f\"{typeName}: {value}\")\n print()\n\n def getLength(self):\n return len(self.messageBuffer)\n\n def isServerToClient(self):\n messageType = self.getMessageType()\n if 20000 <= messageType < 30000 or messageType == 40000:\n return True\n elif 10000 <= messageType < 20000 or messageType == 30000:\n return False" } ]

[ { "identifier": "make_schema", "path": "aiodesa/utils/table.py", "snippet": "def make_schema(name: str, data_cls: Any) -> TableSchema:\n \"\"\"\n Generate a TableSchema based on the provided data class.\n\n Args:\n name: The name of the table.\n data_cls: A data class defining the schema for the table.\n\n Returns:\n TableSchema: An instance of TableSchema containing the table_name and\n SQL data definition.\n\n Example:\n\n .. code-block:: python\n\n user_table_schema = generate_table_schema(name='users', data_cls=User)\n\n Note:\n The function returns a TableSchema instance containing the table_name\n and SQL data definition.\n \"\"\"\n columns = []\n name = name.replace(\" \", \"_\")\n for field_name, field_type in data_cls.__annotations__.items():\n if field_name == \"table_name\":\n pass\n else:\n columns.append(f\"{field_name} {py_to_sql_type(field_type)}\")\n if hasattr(data_cls, \"primary_key\"):\n columns.append(f\"PRIMARY KEY ({data_cls.primary_key})\")\n if hasattr(data_cls, \"unique_key\"):\n columns.append(f\"UNIQUE ({data_cls.unique_key})\")\n\n schema = TableSchema(\n name, f\"CREATE TABLE IF NOT EXISTS {name} (\\n{', '.join(columns)}\\n);\"\n )\n\n return schema" }, { "identifier": "TableSchema", "path": "aiodesa/utils/table.py", "snippet": "class TableSchema:\n \"\"\"\n Represents the schema for a database table.\n\n Args:\n table_name: The name of the table.\n data: The SQL data definition language (DDL) statement.\n\n Example:\n\n .. code-block:: python\n\n # Create a TableSchema for a 'users' table\n user_table_schema = TableSchema(\n table_name='users',\n data='CREATE TABLE users (id INTEGER PRIMARY KEY, name TEXT);')\n\n Note:\n The `data` attribute contains the SQL data definition language (DDL).\n \"\"\"\n\n table_name: str\n data: str" } ]

[ { "identifier": "json_lines_loader", "path": "lab_transformers/utils.py", "snippet": "def json_lines_loader(filepath: Union[str, Path]) -> List[Dict[str, Any]]:\n \"\"\"Loads the JSON lines located at filepath and returns them as a list of flat dictionaries.\"\"\"\n\n jsonl = []\n with open(filepath) as f:\n for line in tqdm(f):\n jsonl.append(json.loads(line))\n\n return jsonl" }, { "identifier": "NpEncoder", "path": "lab_transformers/utils.py", "snippet": "class NpEncoder(json.JSONEncoder):\n \"\"\"A JSONEncoder subclass to handle Numpy integers, floats and arrays when writing JSON lines to disk.\n\n Usage: json.dumps(data, cls=NpEncoder)\n\n This function overwrites the default() method of JSONEncoder to handle additional types; specifically Numpy\n integers, floats and arrays. For all other types, the standard default() method is used for encoding.\n \"\"\"\n\n def default(\n self, obj: Union[np.integer, np.floating, np.ndarray, Any]\n ) -> Union[int, float, List[Any], Any]:\n if isinstance(obj, np.integer):\n return int(obj)\n elif isinstance(obj, np.floating):\n return float(obj)\n elif isinstance(obj, np.ndarray):\n return obj.tolist()\n else:\n return super(NpEncoder, self).default(obj)" } ]

[ { "identifier": "Task", "path": "lm_eval/datatypes.py", "snippet": "class Task:\n repo: str\n repo_n: int\n path_from_root: str\n left_context: str\n right_context: str\n gt: str\n total_tests: int" }, { "identifier": "BaseParser", "path": "lm_eval/context_parser.py", "snippet": "class BaseParser:\n def get_left_and_right_context(self, task: Task) -> tp.Tuple[str, str]:\n \"\"\"\n main method, that returns tuple (left_context, right_context) for the task\n \"\"\"\n raise NotImplementedError()" }, { "identifier": "TrivialContextParser", "path": "lm_eval/context_parser.py", "snippet": "class TrivialContextParser(BaseParser):\n def get_left_and_right_context(self, task: Task) -> tp.Tuple[str, str]:\n \"\"\"\n returns left and right context without processing\n \"\"\"\n return task.left_context, task.right_context" } ]

[ { "identifier": "Message", "path": "backend/chat/models.py", "snippet": "class Message(models.Model):\n room = models.ForeignKey(Room, related_name='messages', on_delete=models.CASCADE)\n # Note, message may have null user – we consider such messages \"system\". These messages\n # initiated by the backend and have no user author. We are not using such messages in\n # the example currently, but leave the opportunity to extend.\n user = models.ForeignKey(User, related_name='messages', on_delete=models.CASCADE, null=True)\n content = models.TextField()\n created_at = models.DateTimeField(auto_now_add=True)" }, { "identifier": "Room", "path": "backend/chat/models.py", "snippet": "class Room(models.Model):\n name = models.CharField(max_length=100, unique=True)\n version = models.PositiveBigIntegerField(default=0)\n created_at = models.DateTimeField(auto_now_add=True)\n bumped_at = models.DateTimeField(auto_now_add=True)\n last_message = models.ForeignKey(\n 'Message', related_name='last_message_rooms',\n on_delete=models.SET_NULL, null=True, blank=True,\n )\n\n def increment_version(self):\n self.version += 1\n self.save()\n return self.version\n\n def __str__(self):\n return self.name" }, { "identifier": "RoomMember", "path": "backend/chat/models.py", "snippet": "class RoomMember(models.Model):\n room = models.ForeignKey(Room, related_name='memberships', on_delete=models.CASCADE)\n user = models.ForeignKey(User, related_name='rooms', on_delete=models.CASCADE)\n joined_at = models.DateTimeField(auto_now_add=True)\n\n class Meta:\n unique_together = ('room', 'user')\n\n def __str__(self):\n return f\"{self.user.username} in {self.room.name}\"" }, { "identifier": "Outbox", "path": "backend/chat/models.py", "snippet": "class Outbox(models.Model):\n method = models.TextField(default=\"publish\")\n payload = models.JSONField()\n partition = models.BigIntegerField(default=0)\n created_at = models.DateTimeField(auto_now_add=True)" }, { "identifier": "CDC", "path": "backend/chat/models.py", "snippet": "class CDC(models.Model):\n method = models.TextField(default=\"publish\")\n payload = models.JSONField()\n partition = models.BigIntegerField(default=0)\n created_at = models.DateTimeField(auto_now_add=True)" }, { "identifier": "MessageSerializer", "path": "backend/chat/serializers.py", "snippet": "class MessageSerializer(serializers.ModelSerializer):\n user = UserSerializer(read_only=True)\n room = MessageRoomSerializer(read_only=True)\n\n class Meta:\n model = Message\n fields = ['id', 'content', 'user', 'room', 'created_at']" }, { "identifier": "RoomSearchSerializer", "path": "backend/chat/serializers.py", "snippet": "class RoomSearchSerializer(serializers.ModelSerializer):\n\n is_member = serializers.BooleanField(read_only=True)\n \n class Meta:\n model = Room\n fields = ['id', 'name', 'created_at', 'is_member']" }, { "identifier": "RoomSerializer", "path": "backend/chat/serializers.py", "snippet": "class RoomSerializer(serializers.ModelSerializer):\n member_count = serializers.SerializerMethodField()\n last_message = LastMessageSerializer(read_only=True)\n\n def get_member_count(self, obj):\n return obj.member_count\n\n class Meta:\n model = Room\n fields = ['id', 'name', 'version', 'bumped_at', 'member_count', 'last_message']" }, { "identifier": "RoomMemberSerializer", "path": "backend/chat/serializers.py", "snippet": "class RoomMemberSerializer(serializers.ModelSerializer):\n user = UserSerializer(read_only=True)\n room = RoomSerializer(read_only=True)\n \n class Meta:\n model = RoomMember\n fields = ['room', 'user']" } ]

[ { "identifier": "accuracy", "path": "SCDM/eval.py", "snippet": "def accuracy(y_pred, y_true, threshold=0.5, weights=None):\n pred = np.array(y_pred)\n true = np.array(y_true)\n result = np.where(pred > threshold, 1, 0)\n if weights is not None:\n correct = np.sum((true == result) * weights)\n total = np.sum(weights)\n return correct / total\n else:\n return metrics.accuracy_score(true, result)" }, { "identifier": "area_under_curve", "path": "SCDM/eval.py", "snippet": "def area_under_curve(y_pred, y_true):\n pred = np.array(y_pred)\n true = np.array(y_true)\n fpr, tpr, thresholds = metrics.roc_curve(true, pred)\n return metrics.auc(fpr, tpr)" }, { "identifier": "f1_score", "path": "SCDM/eval.py", "snippet": "def f1_score(y_pred, y_true, threshold=0.5):\n pred = np.array(y_pred)\n true = np.array(y_true)\n result = np.where(pred >= threshold, 1, 0)\n return metrics.f1_score(true, result)" }, { "identifier": "init_interaction_function", "path": "SCDM/utility.py", "snippet": "def init_interaction_function(discrimination, proficiency, q_matrix_line):\n if type(proficiency) is np.ndarray:\n return discrimination * np.sum(proficiency * q_matrix_line)\n else:\n return discrimination * (proficiency * q_matrix_line).sum(dim=1).unsqueeze(1)" } ]

[ { "identifier": "get_tensor_and_expert_parallel_group", "path": "megatron/core/parallel_state.py", "snippet": "def get_tensor_and_expert_parallel_group():\n assert (\n _TENSOR_AND_EXPERT_PARALLEL_GROUP is not None\n ), 'tensor and expert parallel group is not initialized'\n return _TENSOR_AND_EXPERT_PARALLEL_GROUP" }, { "identifier": "get_tensor_model_parallel_group", "path": "megatron/core/parallel_state.py", "snippet": "def get_tensor_model_parallel_group(check_initialized=True):\n \"\"\"Get the tensor model parallel group the caller rank belongs to.\"\"\"\n if check_initialized:\n assert (\n _TENSOR_MODEL_PARALLEL_GROUP is not None\n ), 'tensor model parallel group is not initialized'\n return _TENSOR_MODEL_PARALLEL_GROUP" }, { "identifier": "get_tensor_model_parallel_rank", "path": "megatron/core/parallel_state.py", "snippet": "def get_tensor_model_parallel_rank():\n \"\"\"Return my rank for the tensor model parallel group.\"\"\"\n global _MPU_TENSOR_MODEL_PARALLEL_RANK\n if _MPU_TENSOR_MODEL_PARALLEL_RANK is not None:\n return _MPU_TENSOR_MODEL_PARALLEL_RANK\n return torch.distributed.get_rank(group=get_tensor_model_parallel_group())" }, { "identifier": "get_tensor_model_parallel_world_size", "path": "megatron/core/parallel_state.py", "snippet": "def get_tensor_model_parallel_world_size():\n \"\"\"Return world size for the tensor model parallel group.\"\"\"\n global _MPU_TENSOR_MODEL_PARALLEL_WORLD_SIZE\n if _MPU_TENSOR_MODEL_PARALLEL_WORLD_SIZE is not None:\n return _MPU_TENSOR_MODEL_PARALLEL_WORLD_SIZE\n return torch.distributed.get_world_size(group=get_tensor_model_parallel_group())" }, { "identifier": "split_tensor_along_last_dim", "path": "megatron/core/tensor_parallel/utils.py", "snippet": "def split_tensor_along_last_dim(\n tensor: torch.Tensor, num_partitions: int, contiguous_split_chunks: bool = False,\n) -> List[torch.Tensor]:\n \"\"\" Split a tensor along its last dimension.\n\n Arguments:\n tensor: input tensor.\n num_partitions: number of partitions to split the tensor\n contiguous_split_chunks: If True, make each chunk contiguous\n in memory.\n\n Returns:\n A list of Tensors\n \"\"\"\n # Get the size and dimension.\n last_dim = tensor.dim() - 1\n last_dim_size = divide(tensor.size()[last_dim], num_partitions)\n # Split.\n tensor_list = torch.split(tensor, last_dim_size, dim=last_dim)\n # Note: torch.split does not create contiguous tensors by default.\n if contiguous_split_chunks:\n return tuple(chunk.contiguous() for chunk in tensor_list)\n\n return tensor_list" } ]

[ { "identifier": "CDataJSONEncoder", "path": "src/wechat_pyrobot/ctypes_json.py", "snippet": "class CDataJSONEncoder(JSONEncoder):\r\n def default(self, obj):\r\n if isinstance(obj, (Array, list)):\r\n return [self.default(e) for e in obj]\r\n\r\n if isinstance(obj, _Pointer):\r\n return self.default(obj.contents) if obj else None\r\n\r\n if isinstance(obj, _SimpleCData):\r\n return self.default(obj.value)\r\n\r\n if isinstance(obj, (bool, int, float, str)):\r\n return obj\r\n\r\n if obj is None:\r\n return obj\r\n\r\n if isinstance(obj, (Structure, Union)):\r\n result = {}\r\n anonymous = getattr(obj, '_anonymous_', [])\r\n\r\n for key, *_ in getattr(obj, '_fields_', []):\r\n value = getattr(obj, key)\r\n\r\n # private fields don't encode\r\n if key.startswith('_'):\r\n continue\r\n\r\n if key in anonymous:\r\n result.update(self.default(value))\r\n else:\r\n result[key] = self.default(value)\r\n\r\n return result\r\n\r\n return JSONEncoder.default(self, obj)" }, { "identifier": "CALL_OFFSET", "path": "src/wechat_pyrobot/offset.py", "snippet": "CALL_OFFSET = {\r\n \"3.9.8.12\": {\r\n \"SendMsgFreeCallOffset\": 0x823370,\r\n \"SendTextCallOffset\": 0xDE22D0,\r\n \"SendImageCall0Offset\": 0x821E40,\r\n \"SendImageCall1Offset\": 0xDE1880,\r\n \"SendImageCall2Offset\": 0xF755C0,\r\n \"LogEnterCallOffset\": 0x102C250,\r\n \"LogLeaveCallOffset\": 0x102C584,\r\n \"HookMsgCallOffset\": 0xE0F743,\r\n \"RevokeMsgCallOffset\": 0xE14880,\r\n },\r\n \"3.9.8.15\": {\r\n \"SendMsgFreeCallOffset\": 0x94E590,\r\n \"SendTextCallOffset\": 0x1091CE0,\r\n \"SendImageCall0Offset\": 0x94CD10,\r\n \"SendImageCall1Offset\": 0x10911F0,\r\n \"LogEnterCallOffset\": 0x13D6380,\r\n \"LogLeaveCallOffset\": 0x13D6380,\r\n \"HookMsgCallOffset\": 0x10E8E30,\r\n \"RevokeMsgCallOffset\": 0x10E2A50,\r\n }\r\n}" } ]

[ { "identifier": "ReactiveDiscreteHarness", "path": "simharness2/environments/reactive.py", "snippet": "class ReactiveHarness(RLHarness): # noqa: D205,D212,D415\n def __init__(self, config: EnvContext) -> None:\n def set_trial_results_path(self, path: str) -> None:\n def step(\n self, action: np.ndarray\n ) -> Tuple[np.ndarray, float, bool, bool, Dict[str, Any]]: # noqa\n def _do_one_agent_step(self, action: np.ndarray) -> None:\n def _parse_action(self, action: np.ndarray) -> Tuple[int, int]:\n def _update_agent_position(self) -> None:\n def _agent_pos_is_unburned(self) -> bool:\n def _update_mitigation(self) -> None:\n def _do_one_simulation_step(self) -> bool:\n def _run_simulation(self):\n def _run_benchmark(self):\n def _update_state(self):\n def reset(\n self,\n *,\n seed: Optional[int] = None,\n options: Optional[Dict[Any, Any]] = None,\n ) -> Tuple[np.ndarray, Dict[Any, Any]]: # noqa\n def get_nonsim_attribute_bounds(self) -> OrderedDict[str, Dict[str, int]]: # noqa\n def get_nonsim_attribute_data(self) -> OrderedDict[str, np.ndarray]: # noqa\n def render(self): # noqa\n def _configure_env_rendering(self, should_render: bool) -> None:\n def _increment_evaluation_iterations(self) -> None:\n def _set_agent_pos_for_episode_start(self):\n def _log_env_init(self):\n def _log_env_reset(self):\n def _setup_harness_analytics(self, harness_analytics_partial: partial) -> None:\n def _setup_reward_cls(self, reward_cls_partial: partial) -> None:" }, { "identifier": "get_simulation_from_name", "path": "simharness2/sim_registry.py", "snippet": "def get_simulation_from_name(name: str) -> Tuple[Type[Simulation], Config, Config]:\n \"\"\"\n Return the simulation class and config files associated with the given name.\n\n Arguments:\n name (str): Name of the requested simulation\n\n Raises:\n KeyError: Assert that the simulation has been registered with the\n simulation registry\n\n Returns:\n Tuple(Type[Simulation], Config, Config): Tuple of the simulation class and\n train/eval configs associated with the given name\n \"\"\"\n if name not in _simulation_registry:\n raise KeyError(\n f\"Error: unknown simulation type {name}, \"\n \"the only registed simulation types are: \"\n f\"{list(_simulation_registry.keys())}!\"\n )\n return _simulation_registry[name]" } ]

[ { "identifier": "IDP", "path": "eviloauth/idp.py", "snippet": "class IDP():\n idps = get_idps()\n authz_endpoint = 'https://login.microsoftonline.com/common/oauth2/v2.0/authorize'\n token_endpoint = 'https://login.microsoftonline.com/common/oauth2/v2.0/token'\n\n def __init__(self, idp, redirect_server, **kwargs):\n\n if idp not in self.idps:\n raise EviloauthCommandException(\n f'IDP {idp} is not supported. Supported IDPs: {self.idps}')\n\n self.redirect_server = redirect_server\n self.idp = idp\n self.client_id = kwargs.get('client_id')\n self.scope = kwargs.get('scope')\n self.final_destination = kwargs.get('final_destination')\n app.config['TOKEN_ENDPOINT'] = self.token_endpoint\n self.__idp_setup__()\n\n def __idp_setup__(self):\n if not self.client_id or not self.scope or not self.final_destination:\n self.client_id = prompt('Client ID: ')\n self.scope = prompt('Scope: ')\n self.final_destination = prompt('Final Destination: ')\n\n app.config['CLIENT_ID'] = self.client_id\n app.config['SCOPE'] = self.scope\n app.config['FINAL_DESTINATION'] = self.final_destination\n\n if self.idp == 'entra_implicit_flow':\n self.response_type = 'token'\n self.redirect_uri = f'https://{self.redirect_server}/redirect'\n\n app.config['REDIRECT_URI'] = self.redirect_uri\n app.config['RESPONSE_TYPE'] = self.response_type\n\n params = {\n 'client_id': self.client_id,\n 'scope': self.scope,\n 'response_type': self.response_type,\n 'redirect_uri': f'https://{self.redirect_server}/redirect'\n }\n self.uri = requests.Request(\n 'GET', self.authz_endpoint, params=params).prepare().url\n\n elif self.idp == 'entra_code_flow':\n self.response_type = 'code'\n self.redirect_uri = f'https://{self.redirect_server}/hook'\n self.state = self.__generate_state__()\n self.code_verifier = self.__generate_code_verifier__()\n self.code_challenge = self.__generate_code_challenge__(\n self.code_verifier)\n self.code_challenge_method = 'S256'\n\n app.config['TOKEN_ENDPOINT'] = self.token_endpoint\n app.config['REDIRECT_URI'] = self.redirect_uri\n app.config['RESPONSE_TYPE'] = self.response_type\n app.config['STATE'] = self.state\n app.config['CODE_VERIFIER'] = self.code_verifier\n app.config['CODE_CHALLENGE'] = self.code_challenge\n app.config['CODE_CHALLENGE_METHOD'] = self.code_challenge_method\n\n params = {\n 'client_id': self.client_id,\n 'scope': self.scope,\n 'response_type': self.response_type,\n 'redirect_uri': self.redirect_uri,\n 'state': self.state,\n 'code_challenge': self.code_challenge,\n 'code_challenge_method': self.code_challenge_method\n }\n self.uri = requests.Request(\n 'GET', self.authz_endpoint, params=params).prepare().url\n logging.info(self.uri)\n\n def __generate_state__(self):\n return ''.join([str(random.randint(0, 9)) for _ in range(5)])\n\n def __generate_code_verifier__(self):\n allowed_chars = string.ascii_letters + string.digits + \"-._~\"\n return ''.join([random.choice(allowed_chars) for _ in range(48)])\n\n def __generate_code_challenge__(self, code_verifier):\n code_verifier_encoded = code_verifier.encode()\n code_verifier_digest = hashlib.sha256(code_verifier_encoded).digest()\n code_challenge = base64.urlsafe_b64encode(\n code_verifier_digest).decode().replace('=', '')\n return code_challenge\n\n def __str__(self):\n idp_str = f'{self.idp}'\n idp_str += f'\\n\\tClient ID: {self.client_id}'\n idp_str += f'\\n\\tScope: {self.scope}'\n idp_str += f'\\n\\tFinal Destination: {self.final_destination}'\n return idp_str\n\n def __repr__(self):\n return self.__str__()" }, { "identifier": "EviloauthCommandException", "path": "eviloauth/exceptions.py", "snippet": "class EviloauthCommandException(Exception):\n\n def __init__(self, message=\"An error occurred in Eviloauth command execution\"):\n super().__init__(message)" } ]

[ { "identifier": "PostgresqlNameTypeMapper", "path": "querky/backends/postgresql/name_type_mapper.py", "snippet": "class PostgresqlNameTypeMapper(PostgresqlTypeMapper):\n def __init__(self, typemap: dict[str, dict[str, TypeMetaData]]):\n self.type_cache = dict()\n # копируем\n self.typemap = {\n schema_name: {\n type_name: type_metadata\n for type_name, type_metadata in schema_map.items()\n }\n for schema_name, schema_map in typemap.items()\n }\n\n def set_mapping(self, schema: str, type_name: str, metadata: TypeMetaData) -> None:\n if schema not in self.typemap:\n self.typemap[schema] = dict()\n s = self.typemap[schema]\n s[type_name] = metadata\n\n async def get_pg_type(self, contract: Contract, conn, oid: int):\n if (pg_type := self.type_cache.get(oid, None)) is None:\n pg_type = await contract.raw_fetchone(conn, GET_PG_TYPE_SQL_QUERY, (oid, ))\n self.type_cache[pg_type] = pg_type\n return pg_type\n\n def get_pg_type_sync(self, contract: Contract, conn, oid: int):\n if (pg_type := self.type_cache.get(oid, None)) is None:\n pg_type = contract.raw_fetchone_sync(conn, GET_PG_TYPE_SQL_QUERY, (oid, ))\n self.type_cache[pg_type] = pg_type\n return pg_type\n\n def get_type_knowledge_impl(self, pg_type) -> TypeKnowledge:\n basename: str = pg_type['type_string']\n schema: str = pg_type['namespace_string']\n\n is_array = basename.endswith(\"[]\")\n if is_array:\n basename = basename[:-2]\n try:\n transforms = self.typemap[schema]\n except KeyError:\n raise KeyError(f\"No transforms for schema: {schema} ({basename})\")\n\n try:\n metadata = transforms[basename]\n except KeyError:\n raise KeyError(f\"No metadata for type: {schema}.{basename} (array={is_array})\")\n\n return TypeKnowledge(\n metadata,\n is_array=is_array,\n is_optional=None\n )\n\n async def get_type_knowledge(self, contract: Contract, conn, oid: int) -> TypeKnowledge:\n return self.get_type_knowledge_impl(await self.get_pg_type(contract, conn, oid))\n\n def get_type_knowledge_sync(self, contract: Contract, conn, oid: int) -> TypeKnowledge:\n return self.get_type_knowledge_impl(self.get_pg_type_sync(contract, conn, oid))" }, { "identifier": "TypeMetaData", "path": "querky/base_types.py", "snippet": "class TypeMetaData(GetImportsMixin):\n counterpart: str\n required_imports: set[str] | None = None\n\n def get_imports(self) -> set[str]:\n if self.required_imports is None:\n return set()\n return set(self.required_imports)\n\n @classmethod\n def from_type(cls, t: typing.Type) -> TypeMetaData:\n type_name = t.__name__\n module_path = t.__module__\n return TypeMetaData(\n counterpart=type_name,\n required_imports={f\"from {module_path} import {type_name}\"}\n )" }, { "identifier": "DATETIME_MODULE", "path": "querky/common_imports.py", "snippet": "DATETIME_MODULE = \"import datetime\"" }, { "identifier": "DECIMAL", "path": "querky/common_imports.py", "snippet": "DECIMAL = \"from decimal import Decimal\"" }, { "identifier": "UUID", "path": "querky/common_imports.py", "snippet": "UUID = \"from uuid import UUID\"" }, { "identifier": "UNION", "path": "querky/common_imports.py", "snippet": "UNION = \"from typing import Union\"" } ]

[ { "identifier": "WarmupMultiStepLR", "path": "utils/lr_scheduler.py", "snippet": "class WarmupMultiStepLR(WarmupLR):\r\n\r\n def __init__(self,\r\n optimizer,\r\n milestones,\r\n gamma=0.1,\r\n warmup_epochs=0,\r\n warmup_powers=1,\r\n warmup_lrs=0,\r\n last_epoch=-1):\r\n\r\n if not list(milestones) == sorted(milestones):\r\n raise ValueError('Milestones should be a list of'\r\n ' increasing integers. Got %s' % repr(milestones))\r\n self.milestones = milestones\r\n self.gamma = gamma\r\n super(WarmupMultiStepLR, self).__init__(optimizer,\r\n warmup_epochs,\r\n warmup_powers,\r\n warmup_lrs,\r\n last_epoch)\r\n if self.milestones[0] <= max(self.warmup_epochs):\r\n raise ValueError('milstones[0] ({}) <= max(warmup_epochs) ({})'.format(\r\n milestones[0], max(self.warmup_epochs)))\r\n\r\n def get_single_lr_after_warmup(self, group_index):\r\n factor = self.gamma ** bisect_right(self.milestones, self.last_epoch)\r\n return self.base_lrs[group_index] * factor\r" }, { "identifier": "WarmupCosineAnnealingLR", "path": "utils/lr_scheduler.py", "snippet": "class WarmupCosineAnnealingLR(WarmupLR):\r\n\r\n def __init__(self,\r\n optimizer,\r\n total_epoch,\r\n final_factor=0,\r\n warmup_epochs=0,\r\n warmup_powers=1,\r\n warmup_lrs=0,\r\n last_epoch=-1):\r\n self.total_epoch = total_epoch\r\n self.final_factor = final_factor\r\n super(WarmupCosineAnnealingLR, self).__init__(optimizer,\r\n warmup_epochs,\r\n warmup_powers,\r\n warmup_lrs,\r\n last_epoch)\r\n\r\n def get_single_lr_after_warmup(self, group_index):\r\n warmup_epoch = self.warmup_epochs[group_index]\r\n progress = (self.last_epoch - warmup_epoch) / (self.total_epoch - warmup_epoch)\r\n progress = min(progress, 1.0)\r\n cosine_progress = (math.cos(math.pi * progress) + 1) / 2\r\n factor = cosine_progress * (1 - self.final_factor) + self.final_factor\r\n return self.base_lrs[group_index] * factor\r" } ]

[ { "identifier": "get_tailscale_ip4", "path": "functions.py", "snippet": "def get_tailscale_ip4() -> str:\n try:\n output = subprocess.check_output(\n [\"tailscale\", \"ip\", \"-4\"],\n stderr=subprocess.STDOUT,\n universal_newlines=True,\n )\n ip = output.strip()\n if is_valid_ip(ip):\n return ip\n except subprocess.CalledProcessError as e:\n logger.error(e)\n return \"\"" }, { "identifier": "get_tailscale_ip6", "path": "functions.py", "snippet": "def get_tailscale_ip6() -> str:\n try:\n output = subprocess.check_output(\n [\"tailscale\", \"ip\", \"-6\"],\n stderr=subprocess.STDOUT,\n universal_newlines=True,\n )\n ip = output.strip()\n if is_valid_ip(ip):\n return ip\n except subprocess.CalledProcessError as e:\n logger.error(e)\n return \"\"" } ]

[ { "identifier": "is_list", "path": "src/nexon_openapi/utils/_utils.py", "snippet": "def is_list(obj: object) -> TypeGuard[list[object]]:\n return isinstance(obj, list)" }, { "identifier": "is_mapping", "path": "src/nexon_openapi/utils/_utils.py", "snippet": "def is_mapping(obj: object) -> TypeGuard[Mapping[str, object]]:\n return isinstance(obj, Mapping)" }, { "identifier": "is_list_type", "path": "src/nexon_openapi/utils/_utils.py", "snippet": "def is_list_type(typ: type) -> bool:\n return (get_origin(typ) or typ) == list" }, { "identifier": "is_union_type", "path": "src/nexon_openapi/utils/_utils.py", "snippet": "def is_union_type(typ: type) -> bool:\n return _is_union(get_origin(typ))" }, { "identifier": "extract_type_arg", "path": "src/nexon_openapi/utils/_utils.py", "snippet": "def extract_type_arg(typ: type, index: int) -> type:\n args = get_args(typ)\n try:\n return cast(type, args[index])\n except IndexError as err:\n raise RuntimeError(f\"Expected type {typ} to have a type argument at index {index} but it did not\") from err" }, { "identifier": "is_required_type", "path": "src/nexon_openapi/utils/_utils.py", "snippet": "def is_required_type(typ: type) -> bool:\n return get_origin(typ) == Required" }, { "identifier": "is_annotated_type", "path": "src/nexon_openapi/utils/_utils.py", "snippet": "def is_annotated_type(typ: type) -> bool:\n return get_origin(typ) == Annotated" }, { "identifier": "strip_annotated_type", "path": "src/nexon_openapi/utils/_utils.py", "snippet": "def strip_annotated_type(typ: type) -> type:\n if is_required_type(typ) or is_annotated_type(typ):\n return strip_annotated_type(cast(type, get_args(typ)[0]))\n\n return typ" }, { "identifier": "model_dump", "path": "src/nexon_openapi/_compat.py", "snippet": "def model_dump(\n model: pydantic.BaseModel,\n *,\n exclude_unset: bool = False,\n exclude_defaults: bool = False,\n) -> Dict[str, Any]:\n if PYDANTIC_V2:\n return model.model_dump(\n exclude_unset=exclude_unset,\n exclude_defaults=exclude_defaults,\n )\n return cast(\n \"dict[str, Any]\",\n model.dict( # pyright: ignore[reportDeprecated, reportUnnecessaryCast]\n exclude_unset=exclude_unset,\n exclude_defaults=exclude_defaults,\n ),\n )" }, { "identifier": "is_typeddict", "path": "src/nexon_openapi/_compat.py", "snippet": "def is_typeddict(type_: Type[Any]) -> bool: # noqa: ARG001\n ..." } ]

[ { "identifier": "get_unk_mask_indices", "path": "dataloaders/data_utils.py", "snippet": "def get_unk_mask_indices(image,testing,num_labels,known_labels,epoch=1):\n if testing:\n # for consistency across epochs and experiments, seed using hashed image array \n random.seed(hashlib.sha1(np.array(image)).hexdigest())\n unk_mask_indices = random.sample(range(num_labels), (num_labels-int(known_labels)))\n else:\n # sample random number of known labels during training\n if known_labels>0:\n random.seed()\n num_known = random.randint(0,int(num_labels*0.75))\n else:\n num_known = 0\n\n unk_mask_indices = random.sample(range(num_labels), (num_labels-num_known))\n\n return unk_mask_indices" }, { "identifier": "image_loader", "path": "dataloaders/data_utils.py", "snippet": "def image_loader(path,transform):\n try:\n image = Image.open(path)\n except FileNotFoundError: # weird issues with loading images on our servers\n # print('FILE NOT FOUND')\n time.sleep(10)\n image = Image.open(path)\n\n image = image.convert('RGB')\n\n if transform is not None:\n image = transform(image)\n\n return image" } ]

[ { "identifier": "CowCategoryChoices", "path": "core/choices.py", "snippet": "class CowCategoryChoices(models.TextChoices):\n \"\"\"\n Choices for the category of a cow.\n\n Choices:\n - `CALF`: Represents a calf.\n - `WEANER`: Represents a weaner.\n - `HEIFER`: Represents a heifer.\n - `BULL`: Represents a bull.\n - `MILKING_COW`: Represents a milking cow.\n\n Usage:\n These choices represent the category of a cow in the Cow model.\n Use these choices when defining or querying Cow instances to represent the category of a cow.\n\n Example:\n ```\n class Cow(models.Model):\n category = models.CharField(max_length=15, choices=CowCategoryChoices.choices)\n ```\n \"\"\"\n\n CALF = \"Calf\"\n WEANER = \"Weaner\"\n HEIFER = \"Heifer\"\n BULL = \"Bull\"\n MILKING_COW = \"Milking Cow\"" }, { "identifier": "CowAvailabilityChoices", "path": "core/choices.py", "snippet": "class CowAvailabilityChoices(models.TextChoices):\n \"\"\"\n Choices for the availability status of a cow.\n\n Choices:\n - `ALIVE`: Cow is alive and active.\n - `SOLD`: Cow has been sold.\n - `DEAD`: Cow has died.\n\n Usage:\n These choices represent the availability status of a cow in the Cow model.\n Use these choices when defining or querying Cow instances to represent the current status of a cow.\n\n Example:\n ```\n class Cow(models.Model):\n availability_status = models.CharField(max_length=50, choices=CowAvailabilityChoices.choices)\n ```\n \"\"\"\n\n ALIVE = \"Alive\"\n SOLD = \"Sold\"\n DEAD = \"Dead\"" }, { "identifier": "todays_date", "path": "core/utils.py", "snippet": "" }, { "identifier": "LactationStageChoices", "path": "production/choices.py", "snippet": "class LactationStageChoices(models.TextChoices):\n \"\"\"\n Choices for the stage of lactation.\n\n Choices:\n - `EARLY`: Early stage of lactation.\n - `MID`: Mid stage of lactation.\n - `LATE`: Late stage of lactation.\n - `DRY`: Dry stage (post-lactation).\n - `ENDED`: Lactation has ended.\n\n Usage:\n These choices represent the stage of lactation in the Lactation model and are utilized in the LactationManager\n to determine lactation stages based on the number of days.\n\n Example:\n ```\n class Lactation(models.Model):\n lactation_stage = models.CharField(\n max_length=5,\n choices=LactationStageChoices.choices,\n default=LactationStageChoices.DRY,\n )\n ```\n\n Manager Usage:\n The `LactationManager` uses these choices in the `lactation_stage` method to determine the stage of lactation\n based on the number of days.\n\n Example:\n ```\n class LactationManager(models.Manager):\n ...\n\n def lactation_stage(self, lactation):\n days_in_lactation = self.days_in_lactation(lactation)\n\n if lactation.end_date:\n return LactationStageChoices.ENDED\n elif days_in_lactation <= 100:\n return LactationStageChoices.EARLY\n elif days_in_lactation <= 200:\n return LactationStageChoices.MID\n elif days_in_lactation <= 275:\n return LactationStageChoices.LATE\n else:\n return LactationStageChoices.DRY\n ```\n \"\"\"\n\n EARLY = \"Early\"\n MID = \"Mid\"\n LATE = \"Late\"\n DRY = \"Dry\"\n ENDED = \"Ended\"" }, { "identifier": "SexChoices", "path": "users/choices.py", "snippet": "class SexChoices(models.TextChoices):\n MALE = \"Male\"\n FEMALE = \"Female\"" } ]

[ { "identifier": "DeepQNetwork", "path": "control/reinforcement_learning/DQN/DeepQNetwork.py", "snippet": "class DeepQNetwork:\n \"\"\"\n Deep Q Network to approximate the Q function\n \"\"\"\n def __init__(self, lr, num_actions, input_dims, fc_dims = [32, 32], opt='adam', loss='mse'):\n\n self.model = Sequential()\n for i in range(len(fc_dims)):\n if i == 0:\n self.model.add(Dense(fc_dims[i], input_shape=(input_dims,), activation='relu'))\n else:\n self.model.add(Dense(fc_dims[i], activation='relu'))\n\n self.model.add(Dense(num_actions, activation='linear'))\n self.model.compile(optimizer=opt, loss=loss)\n self.model.optimizer.learning_rate = lr\n \n def predict(self, state):\n \"\"\"\n Predict the Q values for a given state\n \"\"\"\n return self.model(state).numpy()\n\n def train_on_batch(self, states, q_targets):\n \"\"\"\n Train the network on a batch of states and q_targets\n \"\"\"\n return self.model.train_on_batch(states, q_targets)\n \n def train_batch_gradientTape(self, states, q_targets):\n \"\"\"\n Train the network on a batch of states and q_targets using GradientTape\n \"\"\"\n with tf.GradientTape() as tape:\n predictions = self.model(states)\n loss = tf.keras.losses.MSE(q_targets, predictions)\n gradients = tape.gradient(loss, self.model.trainable_variables)\n self.model.optimizer.apply_gradients(zip(gradients, self.model.trainable_variables))\n # take the mean of the loss\n loss = tf.reduce_mean(loss).numpy()\n return loss\n\n def evaluate(self, states, q_targets, verbose=0):\n \"\"\"\n Evaluate the network on a batch of states and q_targets\n \"\"\"\n return self.model.evaluate(states, q_targets, verbose=verbose)" }, { "identifier": "ReplayBuffer", "path": "control/reinforcement_learning/DQN/ReplayBuffer.py", "snippet": "class ReplayBuffer:\n \"\"\"\n Stores and retrieves gameplay experiences\n \"\"\"\n\n def __init__(self, size):\n self.gameplay_experiences = deque(maxlen=size)\n \n def store_tuple(self, state, action, reward, new_state, done):\n \"\"\"\n Store the experience in the replay buffer\n \"\"\"\n self.gameplay_experiences.append((state, action, reward, new_state, done))\n\n def sample_batch(self, batch_size):\n \"\"\"\n Sample a random batch of experiences from the replay buffer\n \"\"\"\n random_sample = random.sample(self.gameplay_experiences, batch_size)\n states, actions, rewards, new_states, dones = map(np.asarray, zip(*random_sample))\n return states, actions, rewards, new_states, dones" } ]

[ { "identifier": "Debug", "path": "objlog/LogMessages.py", "snippet": "class Debug(LogMessage):\n \"\"\"the default debug message, with blue color\"\"\"\n level = \"DEBUG\"\n color = \"\\033[94m\"" }, { "identifier": "LogMessage", "path": "objlog/Base/LogMessage.py", "snippet": "class LogMessage:\n \"\"\"a base message to be logged\n Attributes:\n color\n level (name)\n\n WARNING: this class should not be used directly, use a subclass instead\n it is designed to be used as a base class for other classes, and will not work properly if used directly.\n \"\"\"\n\n def __init__(self, message):\n self.message = str(message)\n self.timestamp = datetime.now()\n self.unix_timestamp = time_ns() // 1_000_000 # deprecated, use self.unix instead\n self.unix = time_ns() // 1_000_000\n # create uuid\n self.uuid = f\"{time_ns()}-{random.randint(0, 1000)}\"\n try:\n t1 = self.color\n t2 = self.level\n except AttributeError:\n raise TypeError(\"this class should not be used directly, use a subclass instead\")\n\n def __str__(self):\n return f\"[{self.timestamp}] {self.level}: {self.message}\"\n\n def __repr__(self):\n return f\"{self.level}: {self.message}\"\n\n def __eq__(self, other):\n return self.uuid == other.uuid\n\n def __ne__(self, other):\n return self.uuid != other.uuid\n\n def colored(self) -> str:\n \"\"\"return a colored version of the message\"\"\"\n return f\"{self.color}[{self.timestamp}] {self.level}: {self.message}\\033[0m\"" } ]

[ { "identifier": "BaseProvider", "path": "aq/providers/provider.py", "snippet": "class BaseProvider:\n async def create_completion(self, request: ChatCompletionRequest) -> ChatCompletionResponse:\n pass" }, { "identifier": "ProviderError", "path": "aq/providers/provider.py", "snippet": "class ProviderError(Exception):\n def __init__(self, code, message):\n self.code = code\n super().__init__(message)" }, { "identifier": "ChatCompletionMessage", "path": "aq/providers/types/chat.py", "snippet": "class ChatCompletionMessage(BaseModel):\n role: str\n content: Optional[str | List[Content]] = \"\"\n name: Optional[str] = None\n tool_call_id: Optional[str] = None\n tool_calls: Optional[List[ToolCall]] = None" }, { "identifier": "ChatCompletionRequest", "path": "aq/providers/types/chat.py", "snippet": "class ChatCompletionRequest(BaseModel):\n model: str\n messages: List[ChatCompletionMessage]\n tools: Optional[List[Tool]] = None\n response_format: Optional[ResponseFormat] = None\n tool_choice: Optional[str] = None\n temperature: float = 0.5\n presence_penalty: float = 0.0\n frequency_penalty: float = 0.0\n max_tokens: int = 1000" }, { "identifier": "ChatCompletionResponse", "path": "aq/providers/types/chat.py", "snippet": "class ChatCompletionResponse(BaseModel):\n id: str\n object: str\n created: int\n choices: List[Choice]" }, { "identifier": "Choice", "path": "aq/providers/types/chat.py", "snippet": "class Choice(BaseModel):\n index: int\n message: ChatCompletionMessage\n finish_reason: Optional[str] = None" }, { "identifier": "Error", "path": "aq/providers/types/chat.py", "snippet": "class Error(BaseModel):\n code: str | int\n message: str" }, { "identifier": "AsyncHttpClient", "path": "aq/http_client/async_http_client.py", "snippet": "class AsyncHttpClient:\n TIMEOUT = 120\n\n def __init__(self):\n logging.getLogger('httpcore').setLevel(logging.ERROR)\n logging.getLogger('httpx').setLevel(logging.ERROR)\n self._logger = logging.getLogger(self.__class__.__name__)\n\n async def post(self, url: str, headers: Dict[str, Any], data: Any, json=True) -> Any:\n retry_count = 0\n while retry_count < 5:\n try:\n async with httpx.AsyncClient() as ac:\n response = await ac.post(url, headers=headers, data=data, timeout=self.TIMEOUT)\n if json:\n json_response = response.json()\n if \"error\" in json_response and \"code\" in json_response[\"error\"]:\n code = int(json_response[\"error\"][\"code\"])\n if code == 429:\n self._logger.error(\"Received a 429 error. Retrying ...\")\n retry_count += 1\n await asyncio.sleep(5*(2**retry_count))\n else:\n return json_response\n else:\n return json_response\n else:\n return response.text\n except httpx.HTTPStatusError as e:\n if e.response.status_code == 429:\n self._logger.error(\"Received a 429 error. Retrying ...\")\n retry_count += 1\n await asyncio.sleep(5*(2**retry_count))\n else:\n self._logger.error(f\"HTTP error: {e.response.status_code}, {e.response.text}\")\n raise e\n\n async def get(self, url: str, query: Dict[str, Any] = None, headers: [str, Any] = None, json=True) -> Any:\n get_url = f\"{url}?{urlencode(query)}\" if query else url\n async with httpx.AsyncClient() as ac:\n response = await ac.get(get_url, headers=headers or {}, timeout=self.TIMEOUT)\n return response.json() if json else response.text\n\n @staticmethod\n def urljoin(*args):\n stripped = map(lambda x: str(x).strip('/'), args)\n return \"/\".join(stripped)" } ]

[ { "identifier": "get_data_filepaths", "path": "dg_tta/tta/config_log_utils.py", "snippet": "def get_data_filepaths(tta_dataset_name, tta_dataset_bucket):\n raw_tta_dataset_dir = Path(nnUNet_raw, tta_dataset_name)\n if tta_dataset_bucket == \"imagesTr\":\n source_folders = [raw_tta_dataset_dir / \"imagesTr\"]\n elif tta_dataset_bucket == \"imagesTs\":\n source_folders = [raw_tta_dataset_dir / \"imagesTs\"]\n elif tta_dataset_bucket == \"imagesTrAndTs\":\n source_folders = [\n raw_tta_dataset_dir / \"imagesTr\",\n raw_tta_dataset_dir / \"imagesTs\",\n ]\n\n file_list = []\n for src_fld in source_folders:\n if src_fld.is_dir():\n file_list.extend(filter(lambda x: x.is_file(), src_fld.iterdir()))\n\n return file_list" }, { "identifier": "get_dgtta_colormap", "path": "dg_tta/tta/config_log_utils.py", "snippet": "def get_dgtta_colormap():\n hi_1 = \"#248888\"\n hi_2 = \"#79DCF0\"\n hi_3 = \"#e7475e\"\n hi_4 = \"#f0d879\"\n return matplotlib.colors.LinearSegmentedColormap.from_list(\n \"\", [hi_3, hi_4, hi_2, hi_1]\n )" }, { "identifier": "get_resources_dir", "path": "dg_tta/tta/config_log_utils.py", "snippet": "def get_resources_dir():\n return Path(dg_tta.__file__).parent / \"__resources__\"" }, { "identifier": "check_dga_root_is_set", "path": "dg_tta/utils.py", "snippet": "def check_dga_root_is_set(soft_check=False):\n prompt = \"Please define an existing root directory for DG-TTA by setting DG_TTA_ROOT.\"\n check = Path(\n os.environ.get(\"DG_TTA_ROOT\", \"_\")\n ).is_dir()\n\n if soft_check and not check:\n print(prompt)\n return\n\n assert check, prompt" } ]

[ { "identifier": "MLP", "path": "vpt_main/src/models/mlp.py", "snippet": "class MLP(nn.Module):\n def __init__(\n self,\n input_dim: int,\n mlp_dims: List[int],\n dropout: float = 0.1,\n nonlinearity: Type[nn.Module] = nn.ReLU,\n normalization: Type[nn.Module] = nn.BatchNorm1d, # nn.LayerNorm,\n special_bias: bool = False,\n add_bn_first: bool = False,\n ):\n super(MLP, self).__init__()\n projection_prev_dim = input_dim\n projection_modulelist = []\n last_dim = mlp_dims[-1]\n mlp_dims = mlp_dims[:-1]\n\n if add_bn_first:\n if normalization is not None:\n projection_modulelist.append(normalization(projection_prev_dim))\n if dropout != 0:\n projection_modulelist.append(nn.Dropout(dropout))\n\n for idx, mlp_dim in enumerate(mlp_dims):\n fc_layer = nn.Linear(projection_prev_dim, mlp_dim)\n nn.init.kaiming_normal_(fc_layer.weight, a=0, mode='fan_out')\n projection_modulelist.append(fc_layer)\n projection_modulelist.append(nonlinearity())\n\n if normalization is not None:\n projection_modulelist.append(normalization(mlp_dim))\n\n if dropout != 0:\n projection_modulelist.append(nn.Dropout(dropout))\n projection_prev_dim = mlp_dim\n\n self.projection = nn.Sequential(*projection_modulelist)\n self.last_layer = nn.Linear(projection_prev_dim, last_dim)\n nn.init.kaiming_normal_(self.last_layer.weight, a=0, mode='fan_out')\n if special_bias:\n prior_prob = 0.01\n bias_value = -math.log((1 - prior_prob) / prior_prob)\n torch.nn.init.constant_(self.last_layer.bias, bias_value)\n\n def forward(self, x: torch.Tensor) -> torch.Tensor:\n \"\"\"\n input_arguments:\n @x: torch.FloatTensor\n \"\"\"\n x = self.projection(x)\n x = self.last_layer(x)\n return x" }, { "identifier": "logging", "path": "vpt_main/src/utils/logging.py", "snippet": "_FORMAT = \"[%(levelname)s: %(filename)s: %(lineno)4d]: %(message)s\"\ndef _suppress_print():\n def print_pass(*objects, sep=\" \", end=\"\\n\", file=sys.stdout, flush=False):\ndef _cached_log_stream(filename):\ndef setup_logging(\n num_gpu, num_shards, output=\"\", name=\"visual_prompt\", color=True):\ndef setup_single_logging(name, output=\"\"):\ndef get_logger(name):\ndef log_json_stats(stats, sort_keys=True):\n def __init__(self, *args, **kwargs):\n def formatMessage(self, record: logging.LogRecord) -> str:\nclass _ColorfulFormatter(logging.Formatter):" } ]

[ { "identifier": "caculate_bleu", "path": "evaluations.py", "snippet": "def caculate_bleu(results, data, gram):\n bleus = []\n for qid, output in results.items():\n prediction = output\n target = data[qid]\n # target = data[qid]['lecture'] + data[qid]['solution']\n target = target.strip()\n if target == \"\":\n continue\n bleu = bleu_score(target, prediction, gram)\n bleus.append(bleu)\n\n avg_bleu = sum(bleus) / len(bleus)\n\n return avg_bleu" }, { "identifier": "caculate_rouge", "path": "evaluations.py", "snippet": "def caculate_rouge(results, data):\n rouges = []\n for qid, output in results.items():\n prediction = output\n target = data[qid]\n # target = data[qid]['lecture'] + data[qid]['solution']\n target = target.strip()\n if prediction == \"\":\n continue\n if target == \"\":\n continue\n rouge = score_rouge(target, prediction)\n rouges.append(rouge)\n\n avg_rouge = sum(rouges) / len(rouges)\n return avg_rouge" }, { "identifier": "caculate_similariry", "path": "evaluations.py", "snippet": "def caculate_similariry(results, data, model):\n scores = []\n for qid, output in results.items():\n prediction = output\n target = data[qid]\n # target = data[qid]['lecture'] + data[qid]['solution']\n target = target.strip()\n\n score = similariry_score(target, prediction, model)\n scores.append(score)\n\n avg_score = sum(scores) / len(scores)\n return avg_score" } ]

[ { "identifier": "Numeric", "path": "jaxampler/_src/typing.py", "snippet": "" }, { "identifier": "Binomial", "path": "jaxampler/_src/rvs/binomial.py", "snippet": "class Binomial(DiscreteRV):\n r\"\"\"Binomial random variable\n .. math::\n X\\sim Bin(p,n) \\iff P(X=x|p,n)=\\binom{n}{x}p^{x}(1-p)^{n-x}\n \"\"\"\n\n def __init__(self, p: Numeric | Any, n: Numeric | Any, name: Optional[str] = None) -> None:\n \"\"\"\n :param p: Probability of success\n :param n: Number of trials\n :param name: Name of the random variable\n \"\"\"\n shape, self._p, self._n = jx_cast(p, n)\n self.check_params()\n self._q = 1.0 - self._p\n super().__init__(name=name, shape=shape)\n\n def check_params(self) -> None:\n \"\"\"Check the parameters of the random variable.\"\"\"\n assert jnp.all(self._p >= 0.0) and jnp.all(self._p <= 1.0), \"p must be in [0, 1]\"\n assert jnp.all(self._n.dtype == jnp.int32), \"n must be an integer\"\n assert jnp.all(self._n > 0), \"n must be positive\"\n\n @partial(jit, static_argnums=(0,))\n def logpmf_x(self, x: Numeric) -> Numeric:\n return jax_binom.logpmf(x, self._n, self._p)\n\n @partial(jit, static_argnums=(0,))\n def pmf_x(self, x: Numeric) -> Numeric:\n return jax_binom.pmf(x, self._n, self._p)\n\n @partial(jit, static_argnums=(0,))\n def logcdf_x(self, x: Numeric) -> Numeric:\n return jnp.log(self.cdf_x(x))\n\n @partial(jit, static_argnums=(0,))\n def cdf_x(self, x: Numeric) -> Numeric:\n floor_x = jnp.floor(x)\n cond = [x < 0, x >= self._n, jnp.logical_and(x >= 0, x < self._n)]\n return jnp.select(cond, [0.0, 1.0, betainc(self._n - floor_x, floor_x + 1, self._q)])\n\n def rvs(self, shape: tuple[int, ...], key: Optional[Array] = None) -> Array:\n if key is None:\n key = self.get_key()\n new_shape = shape + self._shape\n return jax.random.binomial(key=key, n=self._n, p=self._p, shape=new_shape)\n\n def __repr__(self) -> str:\n string = f\"Binomial(p={self._p}, n={self._n}\"\n if self._name is not None:\n string += f\", name={self._name}\"\n string += \")\"\n return string" } ]

[ { "identifier": "PatchEmbed", "path": "lib/models/layers/patch_embed.py", "snippet": "class PatchEmbed(nn.Module):\r\n \"\"\" 2D Image to Patch Embedding\r\n \"\"\"\r\n\r\n def __init__(self, img_size=224, patch_size=16, in_chans=3, embed_dim=768, norm_layer=None, flatten=True):\r\n super().__init__()\r\n img_size = to_2tuple(img_size)\r\n patch_size = to_2tuple(patch_size)\r\n self.img_size = img_size\r\n self.patch_size = patch_size\r\n self.grid_size = (img_size[0] // patch_size[0], img_size[1] // patch_size[1])\r\n self.num_patches = self.grid_size[0] * self.grid_size[1]\r\n self.flatten = flatten\r\n\r\n self.proj = nn.Conv2d(in_chans, embed_dim, kernel_size=patch_size, stride=patch_size)\r\n self.norm = norm_layer(embed_dim) if norm_layer else nn.Identity()\r\n\r\n def forward(self, x):\r\n # allow different input size\r\n # B, C, H, W = x.shape\r\n # _assert(H == self.img_size[0], f\"Input image height ({H}) doesn't match model ({self.img_size[0]}).\")\r\n # _assert(W == self.img_size[1], f\"Input image width ({W}) doesn't match model ({self.img_size[1]}).\")\r\n x = self.proj(x)\r\n if self.flatten:\r\n x = x.flatten(2).transpose(1, 2) # BCHW -> BNC\r\n x = self.norm(x)\r\n return x\r" }, { "identifier": "combine_tokens", "path": "lib/models/odtrack/utils.py", "snippet": "def combine_tokens(template_tokens, search_tokens, mode='direct', return_res=False):\r\n # [B, HW, C]\r\n len_t = template_tokens.shape[1]\r\n len_s = search_tokens.shape[1]\r\n\r\n if mode == 'direct':\r\n merged_feature = torch.cat((template_tokens, search_tokens), dim=1)\r\n elif mode == 'template_central':\r\n central_pivot = len_s // 2\r\n first_half = search_tokens[:, :central_pivot, :]\r\n second_half = search_tokens[:, central_pivot:, :]\r\n merged_feature = torch.cat((first_half, template_tokens, second_half), dim=1)\r\n elif mode == 'partition':\r\n feat_size_s = int(math.sqrt(len_s))\r\n feat_size_t = int(math.sqrt(len_t))\r\n window_size = math.ceil(feat_size_t / 2.)\r\n # pad feature maps to multiples of window size\r\n B, _, C = template_tokens.shape\r\n H = W = feat_size_t\r\n template_tokens = template_tokens.view(B, H, W, C)\r\n pad_l = pad_b = pad_r = 0\r\n # pad_r = (window_size - W % window_size) % window_size\r\n pad_t = (window_size - H % window_size) % window_size\r\n template_tokens = F.pad(template_tokens, (0, 0, pad_l, pad_r, pad_t, pad_b))\r\n _, Hp, Wp, _ = template_tokens.shape\r\n template_tokens = template_tokens.view(B, Hp // window_size, window_size, W, C)\r\n template_tokens = torch.cat([template_tokens[:, 0, ...], template_tokens[:, 1, ...]], dim=2)\r\n _, Hc, Wc, _ = template_tokens.shape\r\n template_tokens = template_tokens.view(B, -1, C)\r\n merged_feature = torch.cat([template_tokens, search_tokens], dim=1)\r\n\r\n # calculate new h and w, which may be useful for SwinT or others\r\n merged_h, merged_w = feat_size_s + Hc, feat_size_s\r\n if return_res:\r\n return merged_feature, merged_h, merged_w\r\n\r\n else:\r\n raise NotImplementedError\r\n\r\n return merged_feature\r" }, { "identifier": "recover_tokens", "path": "lib/models/odtrack/utils.py", "snippet": "def recover_tokens(merged_tokens, len_template_token, len_search_token, mode='direct'):\r\n if mode == 'direct':\r\n recovered_tokens = merged_tokens\r\n elif mode == 'template_central':\r\n central_pivot = len_search_token // 2\r\n len_remain = len_search_token - central_pivot\r\n len_half_and_t = central_pivot + len_template_token\r\n\r\n first_half = merged_tokens[:, :central_pivot, :]\r\n second_half = merged_tokens[:, -len_remain:, :]\r\n template_tokens = merged_tokens[:, central_pivot:len_half_and_t, :]\r\n\r\n recovered_tokens = torch.cat((template_tokens, first_half, second_half), dim=1)\r\n elif mode == 'partition':\r\n recovered_tokens = merged_tokens\r\n else:\r\n raise NotImplementedError\r\n\r\n return recovered_tokens\r" } ]

[ { "identifier": "Attention", "path": "TestingCode/modules.py", "snippet": "class Attention(nn.Module):\n def __init__(\n self, dim, num_heads=8, qkv_bias=False, attn_drop=0.0, proj_drop=0.0\n ):\n super(Attention, self).__init__()\n\n assert (\n dim % num_heads == 0\n ), \"Embedding dimension should be divisible by number of heads\"\n\n self.num_heads = num_heads\n head_dim = dim // num_heads\n self.scale = head_dim ** -0.5\n\n self.qkv = nn.Linear(dim, dim * 3, bias=qkv_bias)\n self.attn_drop = nn.Dropout(attn_drop)\n self.proj = nn.Linear(dim, dim)\n self.proj_drop = nn.Dropout(proj_drop)\n\n def forward(self, x):\n B, N, C = x.shape\n qkv = (\n self.qkv(x)\n .reshape(B, N, 3, self.num_heads, C // self.num_heads)\n .permute(2, 0, 3, 1, 4)\n )\n # make torchscript happy (cannot use tensor as tuple)\n q, k, v = qkv[0], qkv[1], qkv[2]\n\n attn = (q @ k.transpose(-2, -1)) * self.scale\n attn = attn.softmax(dim=-1)\n attn = self.attn_drop(attn)\n\n x = (attn @ v).transpose(1, 2).reshape(B, N, C)\n x = self.proj(x)\n x = self.proj_drop(x)\n return x" }, { "identifier": "FeedForward", "path": "TestingCode/modules.py", "snippet": "class FeedForward(nn.Module):\n \"\"\"\n Implementation of MLP for transformer\n \"\"\"\n\n def __init__(self, dim, hidden_dim, dropout_rate=0.0, revised=False):\n super(FeedForward, self).__init__()\n if not revised:\n \"\"\"\n Original: https://arxiv.org/pdf/2010.11929.pdf\n \"\"\"\n self.net = nn.Sequential(\n nn.Linear(dim, hidden_dim),\n nn.GELU(),\n nn.Dropout(p=dropout_rate),\n nn.Linear(hidden_dim, dim),\n )\n else:\n \"\"\"\n Scaled ReLU: https://arxiv.org/pdf/2109.03810.pdf\n \"\"\"\n self.net = nn.Sequential(\n nn.Conv1d(dim, hidden_dim, kernel_size=1, stride=1),\n nn.BatchNorm1d(hidden_dim),\n nn.GELU(),\n nn.Dropout(p=dropout_rate),\n nn.Conv1d(hidden_dim, dim, kernel_size=1, stride=1),\n nn.BatchNorm1d(dim),\n nn.GELU(),\n )\n\n self.revised = revised\n self._init_weights()\n\n def _init_weights(self):\n for name, module in self.net.named_children():\n if isinstance(module, nn.Linear):\n nn.init.normal_(module.bias, std=1e-6)\n\n def forward(self, x):\n if self.revised:\n x = x.permute(0, 2, 1)\n x = self.net(x)\n x = x.permute(0, 2, 1)\n else:\n x = self.net(x)\n\n return x" }, { "identifier": "PreNorm", "path": "TestingCode/modules.py", "snippet": "class PreNorm(nn.Module):\n def __init__(self, dim, fn):\n super(PreNorm, self).__init__()\n self.norm = nn.LayerNorm(dim)\n self.fn = fn\n\n def forward(self, x, **kwargs):\n return self.fn(self.norm(x), **kwargs)" } ]

[ { "identifier": "AgentType", "path": "modelscope_agent/agent_types.py", "snippet": "class AgentType(str, Enum):\n\n DEFAULT = 'default'\n \"\"\"\"\"\"\n\n MS_AGENT = 'ms-agent'\n \"\"\"An agent that uses the ModelScope-agent specific format does a reasoning step before acting .\n \"\"\"\n\n MRKL = 'mrkl'\n \"\"\"An agent that does a reasoning step before acting with mrkl\"\"\"\n\n REACT = 'react'\n \"\"\"An agent that does a reasoning step before acting with react\"\"\"\n\n Messages = 'messages'\n \"\"\"An agent optimized for using open AI functions.\"\"\"" }, { "identifier": "LLM", "path": "modelscope_agent/llm/base.py", "snippet": "class LLM:\n name = ''\n\n def __init__(self, cfg):\n self.cfg = cfg\n self.agent_type = None\n self.model = None\n self.model_id = self.model\n\n def set_agent_type(self, agent_type):\n self.agent_type = agent_type\n\n @abstractmethod\n def generate(self, prompt: str, functions: list = [], **kwargs) -> str:\n \"\"\"each llm should implement this function to generate response\n\n Args:\n prompt (str): prompt\n functions (list): list of functions object including: name, description, parameters\n Returns:\n str: response\n \"\"\"\n raise NotImplementedError\n\n @abstractmethod\n def stream_generate(self,\n prompt: str,\n functions: list = [],\n **kwargs) -> str:\n \"\"\"stream generate response, which yields a generator of response in each step\n\n Args:\n prompt (str): prompt\n functions (list): list of functions object including: name, description, parameters\n Yields:\n Iterator[str]: iterator of step response\n \"\"\"\n raise NotImplementedError\n\n def tokenize(self, input_text: str) -> List[int]:\n \"\"\"tokenize is used to calculate the length of the text to meet the model's input length requirements\n\n Args:\n input_text (str): input text\n Returns:\n list[int]: token_ids\n \"\"\"\n raise NotImplementedError\n\n def detokenize(self, input_ids: List[int]) -> str:\n \"\"\"detokenize\n\n Args:\n input_ids (list[int]): input token_ids\n Returns:\n str: text\n \"\"\"\n raise NotImplementedError" }, { "identifier": "DEFAULT_MESSAGE", "path": "modelscope_agent/llm/utils.py", "snippet": "DEFAULT_MESSAGE = {\n 'role': 'user',\n 'content': 'No entry from user - please suggest something to enter'\n}" } ]

[ { "identifier": "GPT", "path": "transformer.py", "snippet": "class GPT(nn.Module):\n def __init__(self, config: GPTConfig):\n super().__init__()\n assert config.vocab_size is not None\n assert config.block_size is not None\n self.config = config\n\n self.wte = nn.Embedding(config.vocab_size, config.n_embd)\n self.wpe = nn.Embedding(config.block_size, config.n_embd)\n self.drop = nn.Dropout(config.dropout)\n self.h = [Block(config) for _ in range(config.n_layer)]\n self.ln_f = nn.LayerNorm(config.n_embd, affine=config.bias)\n\n def _forward_transformer_blocks(\n self, x: mx.array, pos: mx.array, mask=None, cache=None, build_cache=False\n ):\n tok_emb = self.wte(x)\n pos_emb = self.wpe(pos)\n x = self.drop(tok_emb + pos_emb)\n kv_cache = []\n\n if cache is not None:\n for i in range(len(cache)):\n x, cache[i] = self.h[i](x, mask=None, cache=cache[i])\n else:\n for block in self.h:\n x, curr_cache = block(x, mask=mask)\n if build_cache:\n kv_cache.append(curr_cache)\n\n x = self.ln_f(x)\n return x, kv_cache if build_cache else cache\n\n def _create_causal_mask(self, length: int):\n mask = nn.MultiHeadAttention.create_additive_causal_mask(length)\n return mask.astype(self.wte.weight.dtype)\n\n def _sample_next_token(self, x, temperature):\n logits = mx.expand_dims(x[:, -1], axis=0) @ self.wte.weight.T\n y = logits[:, -1, :]\n y = mx.random.categorical(y * (1 / temperature))\n return y\n\n def generate(self, x: mx.array, max_new_tokens=256, temperature=0.8):\n _, t = x.shape\n pos = mx.arange(0, t, 1, dtype=x.dtype)\n mask = self._create_causal_mask(t)\n x, cache = self._forward_transformer_blocks(x, pos, mask=mask, build_cache=True)\n y = self._sample_next_token(x, temperature)\n position = t\n yield y\n\n for _ in range(max_new_tokens):\n position += 1\n x = y[:, None]\n x, cache = self._forward_transformer_blocks(x, position, cache=cache)\n y = self._sample_next_token(x, temperature)\n yield y\n\n def __call__(self, x: mx.array, targets: mx.array = None):\n b, t = x.shape\n assert (\n t <= self.config.block_size\n ), f\"Cannot forward sequence of length {t}, block size is only {self.config.block_size}\"\n pos = mx.arange(0, t, 1, dtype=x.dtype)\n\n mask = self._create_causal_mask(t)\n x, _ = self._forward_transformer_blocks(x, pos, mask=mask)\n\n return x @ self.wte.weight.T\n\n def loss(self, x, y):\n logits = self(x)\n loss = nn.losses.cross_entropy(\n logits.reshape(-1, logits.shape[-1]), y.reshape(-1)\n )\n mx.simplify(loss)\n\n return mx.mean(loss)" }, { "identifier": "GPTConfig", "path": "transformer.py", "snippet": "class GPTConfig:\n block_size: int = 1024\n vocab_size: int = 50304\n n_layer: int = 12\n n_head: int = 12\n n_embd: int = 768\n dropout: float = 0.0\n bias: bool = True" } ]

[ { "identifier": "load_lfqa", "path": "kgw_watermarking/watermark_reliability_release/utils/data/lfqa.py", "snippet": "def load_lfqa(args=None, path=\"./utils/data/lfqa.jsonl\"):\n cols_to_load = [\"prefix\", \"gold_completion\", \"title\", \"selftext\", \"q_id\"]\n\n args.dataset_config_name = None\n args.dataset_split = None\n args.columns_to_remove = list(set(args.columns_to_remove + cols_to_load))\n\n def lfqa_generator():\n for ex in read_jsonlines(path):\n row = {k: ex[k] for k in cols_to_load}\n row[\"prefix\"] = f\"{prompts[args.prompt_id]}{row['prefix']}\"\n yield row\n\n dataset = IterableDataset.from_generator(lfqa_generator)\n return dataset" }, { "identifier": "load_essays", "path": "kgw_watermarking/watermark_reliability_release/utils/data/essays.py", "snippet": "def load_essays(args=None):\n cols_to_load = [\"instructions\", \"essays\"]\n cols_to_remove = [\"titles\", \"urls\", \"__index_level_0__\"]\n\n dataset = load_dataset(\n \"ChristophSchuhmann/essays-with-instructions\",\n streaming=True,\n split=args.dataset_split,\n )\n dataset = dataset.remove_columns(cols_to_remove)\n\n args.dataset_config_name = None\n args.dataset_split = None\n args.columns_to_remove = list(set(args.columns_to_remove + cols_to_load))\n\n return dataset" }, { "identifier": "load_wikitext", "path": "kgw_watermarking/watermark_reliability_release/utils/data/wikitext.py", "snippet": "def load_wikitext(args=None):\n assert args is not None, \"args must be provided to load_wikitext\"\n assert (\n args.dataset_config_name is not None\n ), \"args.dataset_config_name must be None to load_wikitext\"\n assert args.dataset_split is not None, \"args.dataset_split must be None to load_wikitext\"\n\n args.columns_to_remove = list(set(args.columns_to_remove + [\"text\"]))\n\n # load the regular dataset\n raw_dataset = load_dataset(\n args.dataset_name,\n args.dataset_config_name,\n split=args.dataset_split,\n streaming=False, # we're doing this conversion ourselves\n )\n\n def wikitext_generator():\n # the generator loop\n for ex in raw_dataset:\n yield ex\n\n dataset = IterableDataset.from_generator(wikitext_generator)\n return dataset" } ]

[ { "identifier": "interpolate_pos_embed", "path": "util/pos_embed.py", "snippet": "def interpolate_pos_embed(model, checkpoint_model):\n if 'pos_embed' in checkpoint_model:\n pos_embed_checkpoint = checkpoint_model['pos_embed']\n embedding_size = pos_embed_checkpoint.shape[-1]\n num_patches = model.patch_embed.num_patches\n num_extra_tokens = model.pos_embed.shape[-2] - num_patches\n # height (== width) for the checkpoint position embedding\n orig_size = int((pos_embed_checkpoint.shape[-2] - num_extra_tokens) ** 0.5)\n # height (== width) for the new position embedding\n new_size = int(num_patches ** 0.5)\n # class_token and dist_token are kept unchanged\n if orig_size != new_size:\n print(\"Position interpolate from %dx%d to %dx%d\" % (orig_size, orig_size, new_size, new_size))\n extra_tokens = pos_embed_checkpoint[:, :num_extra_tokens]\n # only the position tokens are interpolated\n pos_tokens = pos_embed_checkpoint[:, num_extra_tokens:]\n pos_tokens = pos_tokens.reshape(-1, orig_size, orig_size, embedding_size).permute(0, 3, 1, 2)\n pos_tokens = torch.nn.functional.interpolate(\n pos_tokens, size=(new_size, new_size), mode='bicubic', align_corners=False)\n pos_tokens = pos_tokens.permute(0, 2, 3, 1).flatten(1, 2)\n new_pos_embed = torch.cat((extra_tokens, pos_tokens), dim=1)\n checkpoint_model['pos_embed'] = new_pos_embed" }, { "identifier": "models_vit", "path": "models/models_vit.py", "snippet": "class VisionTransformer(timm.models.vision_transformer.VisionTransformer):\n def __init__(self, global_pool=False, **kwargs):\n def forward_features(self, x):\n def forward_head(self, x):\ndef vit_small_patch16(**kwargs):\ndef vit_base_patch16(**kwargs):\ndef vit_large_patch16(**kwargs):\ndef vit_huge_patch14(**kwargs):\n B = x.shape[0]" } ]

[ { "identifier": "chat_completions", "path": "autogan/oai/openai_utils.py", "snippet": "def chat_completions(messages: list, api_key: Dict, request_timeout: int, max_retries: int,\n stream_mode: Optional[bool] = None):\n \"\"\"OpenAI interface and OpenAI like interface call\n\n :param messages:\n :param api_key: LLM configuration.\n :param request_timeout:\n :param max_retries:\n :param stream_mode:\n \"\"\"\n if api_key[\"api_type\"] == \"openai\" or api_key[\"api_type\"] == \"azure\":\n return openai_chat_completions(messages, api_key, request_timeout, max_retries, stream_mode)\n else:\n return openai_like_chat_completions(messages, api_key, request_timeout, max_retries, stream_mode)" }, { "identifier": "LLMConfig", "path": "autogan/oai/config_utils.py", "snippet": "class LLMConfig:\n \"\"\"LLM config object\n \"\"\"\n\n def __init__(\n self,\n api_key_list: ConfigList,\n max_messages_tokens: str,\n request_interval_time: int,\n request_timeout: int,\n max_retries: int\n ):\n self._api_key_list = api_key_list\n self._max_messages_tokens = max_messages_tokens\n self._request_interval_time = request_interval_time\n self._request_timeout = request_timeout\n self._max_retries = max_retries\n\n def api_key(self, index):\n \"\"\"Get the one configuration in the api_key_list.\n \"\"\"\n return self._api_key_list.get_config(index)\n\n @property\n def next_api_key(self):\n \"\"\"Get the next configuration in the api_key_list.\n \"\"\"\n return self._api_key_list.get_next_config\n\n @property\n def len_of_api_key_list(self) -> int:\n \"\"\"Get the first configuration in the api_key_list list.\n \"\"\"\n return self._api_key_list.len\n\n @property\n def model(self):\n \"\"\"Get the model of the first configuration in the api_key_list list.\n \"\"\"\n return self._api_key_list.get_first_config[\"model\"]\n\n @property\n def max_messages_tokens(self):\n \"\"\"Limit the maximum tokens of the context in each dialogue.\n \"\"\"\n return self._max_messages_tokens\n\n @property\n def request_interval_time(self):\n return self._request_interval_time\n\n @property\n def request_timeout(self):\n return self._request_timeout\n\n @property\n def max_retries(self):\n return self._max_retries" }, { "identifier": "count_text_tokens", "path": "autogan/oai/count_tokens_utils.py", "snippet": "def count_text_tokens(text: str, model: Optional[str] = \"gpt-3.5-turbo\") -> int:\n \"\"\"Calculate the tokens of the text.\n\n :param text: The text to be tokenized\n :param model: Calculate tokens for a specific model. If the model is not listed, it will default to calculating the number of tokens based on the gpt-3.5-turbo standard.\n\n :return: tokens\n \"\"\"\n\n if not text:\n return 0\n\n model_list = ['gpt-4', 'gpt-3.5-turbo-16k', 'gpt-3.5-turbo']\n if model not in model_list:\n model = \"gpt-3.5-turbo\"\n\n try:\n encoding = tiktoken.encoding_for_model(model)\n num_tokens = len(encoding.encode(text))\n except Exception as e:\n print(e)\n num_tokens = 0\n\n return num_tokens" }, { "identifier": "ResponseFuncType", "path": "autogan/utils/response.py", "snippet": " def colored(x, *args, **kwargs):\ndef default_response_func(agent_name: str, gen: str, model: str, stream_mode: bool, index: int,\n content: Optional[str], tokens: Optional[int], response: any):\ndef obj_to_dict(obj):" } ]

[ { "identifier": "crop_HWC_img", "path": "utils/data_util.py", "snippet": "def crop_HWC_img(image, base=64):\r\n \"\"\"\r\n 裁切到multiple of base的size上\r\n :param image: H,W,C\r\n :param base: (int)\r\n :return:\r\n \"\"\"\r\n h = image.shape[0]\r\n w = image.shape[1]\r\n crop_h = h % base\r\n crop_w = w % base\r\n return image[crop_h // 2:h - crop_h + crop_h // 2, crop_w // 2:w - crop_w + crop_w // 2, :]\r" }, { "identifier": "random_augmentation", "path": "utils/data_util.py", "snippet": "def random_augmentation(*args):\r\n out = []\r\n flag_aug = random.randint(0,7)\r\n for data in args:\r\n out.append(data_augmentation(data, flag_aug).copy())\r\n return out\r" }, { "identifier": "padding", "path": "utils/data_util.py", "snippet": "def padding(img, gt_size):\r\n \"\"\"\r\n padding到指定size上\r\n img_lq (np.float32) 0-1 :\r\n img_gt (np.float32) 0-1 :\r\n gt_size (int) :\r\n cv2.BORDER_REPLICATE/cv2.BORDER_CONSTANT,value=(255,255,255)/cv2.BORDER_REFLECT/cv2.BORDER_REFLECT_101/cv2.BORDER_WRAP\"\"\"\r\n h, w, _ = img.shape\r\n\r\n h_pad = max(0, gt_size - h)\r\n w_pad = max(0, gt_size - w)\r\n\r\n if h_pad == 0 and w_pad == 0:\r\n return img\r\n\r\n img = cv2.copyMakeBorder(img, 0, h_pad, 0, w_pad, cv2.BORDER_REFLECT)\r\n # print('img_lq', img_lq.shape, img_gt.shape)\r\n if img_lq.ndim == 2:\r\n img_lq = np.expand_dims(img_lq, axis=2)\r\n if img_gt.ndim == 2:\r\n img_gt = np.expand_dims(img_gt, axis=2)\r\n return img_lq, img_gt\r" }, { "identifier": "onehot", "path": "utils/data_util.py", "snippet": "def onehot(label: int, classes: int):\r\n \"\"\"\r\n return torch.tensor\r\n \"\"\"\r\n onehot_label = np.zeros([1,classes])\r\n onehot_label[:,label] = 1\r\n onehot_label = torch.from_numpy(onehot_label)\r\n return onehot_label\r" }, { "identifier": "smooth_one_hot", "path": "utils/data_util.py", "snippet": "def smooth_one_hot(true_labels: torch.Tensor, classes: int, smoothing=0.0):\r\n \"\"\"\r\n if smoothing == 0, it's one-hot method\r\n if 0 < smoothing < 1, it's smooth method\r\n\r\n \"\"\"\r\n assert 0 <= smoothing < 1\r\n confidence = 1.0 - smoothing\r\n label_shape = torch.Size((true_labels.size(0), classes)) \r\n true_dist = torch.empty(size=label_shape) \r\n true_dist.fill_(smoothing / (classes - 1))\r\n _, index = torch.max(true_labels, 1)\r\n true_dist.scatter_(1, torch.LongTensor(index.unsqueeze(1)), confidence) \r\n return true_dist\r" }, { "identifier": "Degradation", "path": "data/degradation_util.py", "snippet": "class Degradation(object):\r\n def __init__(self, dataset_opt):\r\n super(Degradation, self).__init__()\r\n self.dataset_opt = dataset_opt\r\n self.toTensor = ToTensor()\r\n self.crop_transform = Compose([\r\n ToPILImage(),\r\n RandomCrop(dataset_opt['patch_size']),\r\n ])\r\n\r\n def _add_gaussian_noise(self, clean_patch, sigma):\r\n noise = np.random.randn(*clean_patch.shape)\r\n noisy_patch = np.clip(clean_patch + noise * sigma, 0, 255).astype(np.uint8)\r\n return noisy_patch, clean_patch\r\n\r\n def _degrade_by_type(self, clean_patch, degrade_type):\r\n if degrade_type == 0:\r\n # denoise sigma=15\r\n degraded_patch, clean_patch = self._add_gaussian_noise(clean_patch, sigma=15)\r\n elif degrade_type == 1:\r\n # denoise sigma=25\r\n degraded_patch, clean_patch = self._add_gaussian_noise(clean_patch, sigma=25)\r\n elif degrade_type == 2:\r\n # denoise sigma=50\r\n degraded_patch, clean_patch = self._add_gaussian_noise(clean_patch, sigma=50)\r\n\r\n return degraded_patch, clean_patch\r\n\r\n def degrade(self, clean_patch_1, clean_patch_2, degrade_type=None):\r\n if degrade_type == None:\r\n degrade_type = random.randint(0, 3)\r\n else:\r\n degrade_type = degrade_type\r\n\r\n degrad_patch_1, _ = self._degrade_by_type(clean_patch_1, degrade_type)\r\n degrad_patch_2, _ = self._degrade_by_type(clean_patch_2, degrade_type)\r\n return degrad_patch_1, degrad_patch_2\r\n\r\n def degrade_single(self, clean_patch, degrade_type=None):\r\n if degrade_type == None:\r\n degrade_type = random.randint(0, 3)\r\n else:\r\n degrade_type = degrade_type\r\n \r\n degrad_patch, _ = self._degrade_by_type(clean_patch, degrade_type)\r\n return degrad_patch" } ]

[ { "identifier": "build_transformer_decoder", "path": "Compositor_Mask2Former/mask2former/modeling/transformer_decoder/maskformer_transformer_decoder.py", "snippet": "def build_transformer_decoder(cfg, in_channels, mask_classification=True):\n \"\"\"\n Build a instance embedding branch from `cfg.MODEL.INS_EMBED_HEAD.NAME`.\n \"\"\"\n name = cfg.MODEL.MASK_FORMER.TRANSFORMER_DECODER_NAME\n return TRANSFORMER_DECODER_REGISTRY.get(name)(cfg, in_channels, mask_classification)" }, { "identifier": "build_pixel_decoder", "path": "Compositor_Mask2Former/mask2former/modeling/pixel_decoder/fpn.py", "snippet": "def build_pixel_decoder(cfg, input_shape):\n \"\"\"\n Build a pixel decoder from `cfg.MODEL.MASK_FORMER.PIXEL_DECODER_NAME`.\n \"\"\"\n name = cfg.MODEL.SEM_SEG_HEAD.PIXEL_DECODER_NAME\n model = SEM_SEG_HEADS_REGISTRY.get(name)(cfg, input_shape)\n forward_features = getattr(model, \"forward_features\", None)\n if not callable(forward_features):\n raise ValueError(\n \"Only SEM_SEG_HEADS with forward_features method can be used as pixel decoder. \"\n f\"Please implement forward_features for {name} to only return mask features.\"\n )\n return model" } ]

[ { "identifier": "OpenAIChat", "path": "mirascope/chat/models.py", "snippet": "class OpenAIChat:\n \"\"\"A convenience wrapper for the OpenAI Chat client.\"\"\"\n\n def __init__(self, model: str = \"gpt-3.5-turbo\", api_key: Optional[str] = None):\n \"\"\"Initializes an instance of `OpenAIChat.\"\"\"\n self.client = OpenAI(api_key=api_key)\n self.model = model\n\n def create(self, prompt: Prompt, **kwargs) -> OpenAIChatCompletion:\n \"\"\"Makes a call to the model using `prompt`.\n\n Args:\n prompt: The `Prompt` to use for the call.\n **kwargs: Additional keyword arguments to pass to the API call. You can\n find available keyword arguments here:\n https://platform.openai.com/docs/api-reference/chat/create\n\n Returns:\n A `OpenAIChatCompletion` instance.\n\n Raises:\n Re-raises any exceptions thrown by the openai chat completions create call.\n \"\"\"\n try:\n return OpenAIChatCompletion(\n completion=self.client.chat.completions.create(\n model=self.model,\n messages=get_openai_chat_messages(prompt),\n stream=False,\n **kwargs,\n )\n )\n except:\n raise\n\n def stream(\n self, prompt: Prompt, **kwargs\n ) -> Generator[OpenAIChatCompletionChunk, None, None]:\n \"\"\"Streams the response for a call to the model using `prompt`.\n\n Args:\n prompt: The `Prompt` to use for the call.\n **kwargs: Additional keyword arguments to pass to the API call. You can\n find available keyword arguments here:\n https://platform.openai.com/docs/api-reference/chat/create\n\n Yields:\n A `OpenAIChatCompletionChunk` for each chunk of the response.\n\n Raises:\n Re-raises any exceptions thrown by the openai chat completions create call.\n \"\"\"\n completion_stream = self.client.chat.completions.create(\n model=self.model,\n messages=get_openai_chat_messages(prompt),\n stream=True,\n **kwargs,\n )\n for chunk in completion_stream:\n yield OpenAIChatCompletionChunk(chunk=chunk)" }, { "identifier": "Prompt", "path": "mirascope/prompts.py", "snippet": "class Prompt(BaseModel):\n \"\"\"A Pydantic model for prompts.\"\"\"\n\n @classmethod\n def template(cls) -> str:\n \"\"\"Custom parsing functionality for docstring prompt.\n\n This function is the first step in formatting the prompt template docstring.\n For the default `Prompt`, this function dedents the docstring and replaces all\n repeated sequences of newlines with one fewer newline character. This enables\n writing blocks of text instead of really long single lines. To include any\n number of newline characters, simply include one extra.\n\n Raises:\n ValueError: If the class docstring is empty.\n \"\"\"\n if cls.__doc__ is None:\n raise ValueError(\"`Prompt` must have a prompt template docstring.\")\n\n return re.sub(\n \"(\\n+)\",\n lambda x: x.group(0)[:-1] if len(x.group(0)) > 1 else \" \",\n dedent(cls.__doc__).strip(\"\\n\"),\n )\n\n def __str__(self) -> str:\n \"\"\"Returns the docstring prompt template formatted with template variables.\"\"\"\n template = self.template()\n template_vars = [\n var for _, var, _, _ in Formatter().parse(template) if var is not None\n ]\n return template.format(**{var: getattr(self, var) for var in template_vars})\n\n @property\n def messages(self) -> list[tuple[str, str]]:\n \"\"\"Returns the docstring as a list of messages.\"\"\"\n return [(\"user\", str(self))]\n\n def save(self, filepath: str):\n \"\"\"Saves the prompt to the given filepath.\"\"\"\n with open(filepath, \"wb\") as f:\n pickle.dump(self, f)\n\n @classmethod\n def load(cls, filepath: str) -> Prompt:\n \"\"\"Loads the prompt from the given filepath.\"\"\"\n with open(filepath, \"rb\") as f:\n return pickle.load(f)" } ]

[ { "identifier": "NoRetry", "path": "sqsx/exceptions.py", "snippet": "class NoRetry(Exception):\n \"\"\"\n This exception must be used when we need that the message will be removed from the queue\n \"\"\"\n\n pass" }, { "identifier": "Retry", "path": "sqsx/exceptions.py", "snippet": "class Retry(Exception):\n \"\"\"\n This exception must be used when we need a custom backoff config\n \"\"\"\n\n def __init__(self, min_backoff_seconds: int, max_backoff_seconds: int):\n self.min_backoff_seconds = min_backoff_seconds\n self.max_backoff_seconds = max_backoff_seconds" }, { "identifier": "backoff_calculator_seconds", "path": "sqsx/helper.py", "snippet": "def backoff_calculator_seconds(retries: int, minimum: int, maximum: int) -> int:\n maximum = min(maximum, 43200)\n return min(minimum * 2**retries, maximum)" }, { "identifier": "base64_to_dict", "path": "sqsx/helper.py", "snippet": "def base64_to_dict(data: str) -> dict:\n return json.loads(base64.urlsafe_b64decode(data).decode())" }, { "identifier": "dict_to_base64", "path": "sqsx/helper.py", "snippet": "def dict_to_base64(data: dict) -> str:\n return base64.urlsafe_b64encode(json.dumps(data).encode()).decode()" } ]

[ { "identifier": "TurbopufferError", "path": "turbopuffer/error.py", "snippet": "class TurbopufferError(Exception):\n pass" }, { "identifier": "AuthenticationError", "path": "turbopuffer/error.py", "snippet": "class AuthenticationError(TurbopufferError):\n pass" }, { "identifier": "APIError", "path": "turbopuffer/error.py", "snippet": "class APIError(TurbopufferError):\n def __init__(self, status_code: int, status_name: str, message: str):\n self.status_code = status_code\n self.status_name = status_name\n super().__init__(f'{status_name}: {message}')" } ]

[ { "identifier": "run_one", "path": "multi_label_emg/slurm_utils.py", "snippet": "def run_one(job: str, running_job_count: int, dry_run: bool):\n if ON_SLURM_CLUSTER:\n _run_one_slurm(job, running_job_count, slurm_logs_dir, dry_run)\n else:\n _run_one_local(job, running_job_count, dry_run)" }, { "identifier": "PROJECT_ROOT", "path": "multi_label_emg/utils.py", "snippet": "PROJECT_ROOT = Path(__file__).resolve().parent" } ]

[ { "identifier": "get_config", "path": "config.py", "snippet": "def get_config():\n return {\n 'checkpoints_path': 'checkpoints',\n 'models_path': 'models',\n \n 'tool_dir': 'vendor',\n 'raven_dir': 'vendor/raven-1.8.1',\n 'hifiasm_dir': 'vendor/hifiasm-0.18.8',\n 'pbsim3_dir': 'vendor/pbsim3',\n \n 'sample_profile_id': '',\n 'sample_file': '',\n 'sequencing_depth': 60,\n }" }, { "identifier": "preprocess_graph", "path": "utils.py", "snippet": "def preprocess_graph(g, data_path, idx):\n g = g.int()\n g.ndata['x'] = torch.ones(g.num_nodes(), 1)\n ol_len = g.edata['overlap_length'].float()\n ol_sim = g.edata['overlap_similarity']\n ol_len = (ol_len - ol_len.mean()) / ol_len.std()\n if get_hyperparameters()['use_similarities']:\n g.edata['e'] = torch.cat((ol_len.unsqueeze(-1), ol_sim.unsqueeze(-1)), dim=1)\n else:\n g.edata['e'] = ol_len.unsqueeze(-1)\n return g" }, { "identifier": "add_positional_encoding", "path": "utils.py", "snippet": "def add_positional_encoding(g):\n \"\"\"\n Initializing positional encoding with k-RW-PE\n \"\"\"\n\n g.ndata['in_deg'] = g.in_degrees().float()\n g.ndata['out_deg'] = g.out_degrees().float()\n \n pe_dim = get_hyperparameters()['nb_pos_enc']\n pe_type = get_hyperparameters()['type_pos_enc']\n \n if pe_dim == 0:\n return g\n\n if pe_type == 'RW':\n # Geometric diffusion features with Random Walk\n A = g.adjacency_matrix(scipy_fmt=\"csr\")\n Dinv = sp.diags(dgl.backend.asnumpy(g.in_degrees()).clip(1) ** -1.0, dtype=float) # D^-1\n RW = A @ Dinv \n M = RW\n # Iterate\n PE = [torch.from_numpy(M.diagonal()).float()]\n M_power = M\n for _ in range(pe_dim-1):\n M_power = M_power @ M\n PE.append(torch.from_numpy(M_power.diagonal()).float())\n PE = torch.stack(PE,dim=-1)\n g.ndata['pe'] = PE \n\n if pe_type == 'PR':\n # k-step PageRank features\n A = g.adjacency_matrix(scipy_fmt=\"csr\")\n D = A.sum(axis=1) # out degree\n Dinv = 1./ (D+1e-9); Dinv[D<1e-9] = 0 # take care of nodes without outgoing edges\n Dinv = sp.diags(np.squeeze(np.asarray(Dinv)), dtype=float) # D^-1 \n P = (Dinv @ A).T \n n = A.shape[0]\n One = np.ones([n])\n x = One/ n\n PE = [] \n alpha = 0.95 \n for _ in range(pe_dim): \n x = alpha* P.dot(x) + (1.0-alpha)/n* One \n PE.append(torch.from_numpy(x).float())\n PE = torch.stack(PE,dim=-1)\n g.ndata['pe'] = PE \n\n return g" }, { "identifier": "extract_contigs", "path": "utils.py", "snippet": "def extract_contigs(path, idx):\n gfa_path = os.path.join(path, f'{idx}_asm.bp.p_ctg.gfa')\n asm_path = os.path.join(path, f'{idx}_assembly.fasta')\n contigs = []\n with open(gfa_path) as f:\n n = 0\n for line in f.readlines():\n line = line.strip()\n if line[0] != 'S':\n continue\n seq=Seq.Seq(line.split()[2])\n ctg = SeqIO.SeqRecord(seq, description=f'contig_{n}', id=f'contig_{n}')\n contigs.append(ctg)\n n += 1\n SeqIO.write(contigs, asm_path, 'fasta')\n subprocess.run(f'rm {path}/{idx}_asm*', shell=True)\n # subprocess.run(f'rm {path}/output.csv', shell=True)" } ]

[ { "identifier": "DeviceAPI", "path": "custom_components/sberdevices/api.py", "snippet": "class DeviceAPI:\n def __init__(self, home: HomeAPI, device_id: str) -> None:\n self._home = home\n self._id = device_id\n\n @property\n def device(self) -> dict[str, any]:\n return self._home.get_cached_device(self._id)\n\n async def update(self) -> None:\n await self._home.update_devices_cache()\n\n def get_state(self, key: str) -> dict[str, any]:\n return find_from_list(self.device[\"desired_state\"], key)\n\n def get_attribute(self, key: str) -> dict[str, any]:\n return find_from_list(self.device[\"attributes\"], key)\n\n async def set_states(self, states: [dict[str, any]]) -> None:\n await self._home.set_device_state(self._id, states)\n\n async def set_state(self, state: dict[str, any]) -> None:\n await self.set_states([state])\n\n async def set_state_bool(self, key: str, value: bool) -> None:\n await self.set_state({\"key\": key, \"bool_value\": value})\n\n async def set_state_integer(self, key: str, value: int) -> None:\n await self.set_state({\"key\": key, \"integer_value\": value})\n\n async def set_on_off(self, state: bool) -> None:\n await self.set_state_bool(\"on_off\", state)" }, { "identifier": "HomeAPI", "path": "custom_components/sberdevices/api.py", "snippet": "class HomeAPI:\n def __init__(self, sber: SberAPI) -> None:\n self._sber = sber\n self._client = AsyncClient(\n base_url=\"https://gateway.iot.sberdevices.ru/gateway/v1\",\n )\n self._token_alive = False\n self._devices = {}\n\n async def update_token(self) -> None:\n if self._token_alive:\n return\n\n token = await self._sber.fetch_home_token()\n if token is not None:\n self._client.headers.update({\"X-AUTH-jwt\": token})\n\n async def request(\n self, method: str, url: str, retry: bool = True, **kwargs\n ) -> dict[str, any]:\n await self.update_token()\n\n res = await self._client.request(method, url, **kwargs)\n obj = res.json()\n if res.status_code != 200:\n code = obj[\"code\"]\n # dead token xd\n if code == 16:\n self._token_alive = False\n if retry:\n return await self.request(method, url, retry=False, **kwargs)\n\n raise Exception(f\"{code} ({res.status_code}): {obj['message']}\")\n return obj\n\n async def get_device_tree(self) -> dict[str, any]:\n return (await self.request(\"GET\", \"/device_groups/tree\"))[\"result\"]\n\n # Cache\n async def update_devices_cache(self) -> list[dict[str, any]]:\n self._devices = extract_devices(await self.get_device_tree())\n\n def get_cached_devices(self) -> list[dict[str, any]]:\n return self._devices\n\n def get_cached_device(self, device_id: str) -> dict[str, any]:\n return self._devices[device_id]\n\n async def set_device_state(self, device_id: str, state: [dict[str, any]]) -> None:\n await self._client.request(\n \"PUT\",\n f\"/devices/{device_id}/state\",\n json={\n \"device_id\": device_id,\n \"desired_state\": state,\n \"timestamp\": datetime.now().isoformat()\n + \"Z\", # 2023-12-01T17:00:35.537Z\n },\n )\n\n # Merge\n for state_val in state:\n for attribute in self._devices[device_id][\"desired_state\"]:\n if attribute[\"key\"] == state_val[\"key\"]:\n attribute.update(state_val)\n break" }, { "identifier": "DOMAIN", "path": "custom_components/sberdevices/const.py", "snippet": "DOMAIN = \"sberdevices\"" } ]

[ { "identifier": "BaseTool", "path": "agency_swarm/tools/base_tool.py", "snippet": "class BaseTool(OpenAISchema, ABC):\n def __init__(self, **kwargs):\n super().__init__(**kwargs)\n\n @abstractmethod\n def run(self, **kwargs):\n pass" }, { "identifier": "reference_schema", "path": "agency_swarm/util/schema.py", "snippet": "def reference_schema(schema):\n # Enhanced function to only extract nested properties into $defs\n\n def find_and_extract_defs(node, defs, parent_key=None, path_prefix=\"#/$defs/\"):\n if isinstance(node, dict):\n # Extract nested properties into $defs\n if parent_key == 'properties' and 'properties' in node and isinstance(node['properties'], dict):\n def_name = node.get('title', None)\n if def_name:\n defs[def_name] = node\n return {\"$ref\": path_prefix + def_name}\n\n # Recursively process the dictionary\n return {k: find_and_extract_defs(v, defs, parent_key=k) for k, v in node.items()}\n elif isinstance(node, list):\n # Recursively process the list\n return [find_and_extract_defs(element, defs, parent_key) for element in node]\n else:\n return node\n\n defs = {}\n # Extract definitions and update the schema\n new_schema = {k: find_and_extract_defs(v, defs) for k, v in schema.items()}\n if defs:\n new_schema['parameters'] = new_schema.get('parameters', {})\n new_schema['parameters']['$defs'] = defs\n return new_schema" } ]

[ { "identifier": "TimeDiscretization", "path": "imod/flow/dis.py", "snippet": "class TimeDiscretization(Package):\n \"\"\"\n Time discretisation package class.\n\n Parameters\n ----------\n timestep_duration: xr.DataArray\n is the length of the current stress period (PERLEN). If the flow\n solution is transient, timestep_duration specified here must be equal\n to that specified for the flow model. If the flow solution is\n steady-state, timestep_duration can be set to any desired length.\n n_timesteps: int, optional\n is the number of time steps for the transient flow solution in the\n current stress period (NSTP). If the flow solution is steady-state,\n n_timestep=1. Default value is 1.\n transient: bool, optional\n Flag indicating wether the flow simulation is transient (True) or False\n (Steady State). Default is True.\n timestep_multiplier: float, optional\n is the multiplier for the length of successive time steps used in the\n transient flow solution (TSMULT); it is used only if n_timesteps>1.\n timestep_multiplier>0, the length of each flow time step within the\n current stress period is calculated using the geometric progression as\n in MODFLOW. Note that both n_timesteps and timestep_multiplier\n specified here must be identical to those specified in the flow model\n if the flow model is transient. If timestep_multiplier ≤ 0, the length\n of each flow time step within the current stress period is read from\n the record TSLNGH. This option is needed in case the length of time\n steps for the flow solution is not based on a geometric progression in\n a flow model, unlike MODFLOW. Default is 1.0.\n \"\"\"\n\n _pkg_id = \"dis\"\n _variable_order = [\n \"timestep_duration\",\n \"n_timesteps\",\n \"transient\",\n \"timestep_multiplier\",\n ]\n\n def __init__(\n self,\n timestep_duration,\n endtime,\n n_timesteps=1,\n transient=True,\n timestep_multiplier=1.0,\n ):\n super().__init__()\n self.dataset[\"timestep_duration\"] = timestep_duration\n self.dataset[\"n_timesteps\"] = n_timesteps\n self.dataset[\"transient\"] = transient\n self.dataset[\"timestep_multiplier\"] = timestep_multiplier\n self.endtime = endtime\n\n def _render(self):\n \"\"\"Render iMOD TIM file, which is the time discretization of the iMODFLOW model\"\"\"\n _template = jinja2.Template(\n \"{% for time in timestrings%}\"\n \"{{time}},1,{{n_timesteps}},{{timestep_multiplier}}\\n\"\n \"{% endfor %}\\n\"\n )\n times = self.dataset[\"time\"].values\n timestrings = [imod.util._compose_timestring(time) for time in times]\n timestrings.append(imod.util._compose_timestring(self.endtime))\n\n d = dict(\n timestrings=timestrings,\n n_timesteps=self.dataset[\"n_timesteps\"].item(),\n timestep_multiplier=self.dataset[\"timestep_multiplier\"].item(),\n )\n\n return _template.render(**d)\n\n def save(self, path):\n tim_content = self._render()\n\n with open(path, \"w\") as f:\n f.write(tim_content)\n\n def _pkgcheck(self, **kwargs):\n to_check = [\n \"timestep_duration\",\n \"n_timesteps\",\n ]\n\n self._check_positive(to_check)" }, { "identifier": "timeutil", "path": "imod/wq/timeutil.py", "snippet": "def _check_year(year):\ndef to_datetime(time, use_cftime):\ndef timestep_duration(times, use_cftime):\ndef forcing_starts_ends(package_times, globaltimes):" } ]

[ { "identifier": "MipRayMarcher2", "path": "models/eg3d/volumetric_rendering/ray_marcher.py", "snippet": "class MipRayMarcher2(nn.Module):\n def __init__(self):\n super().__init__()\n\n\n def run_forward(self, colors, densities, depths, rendering_options):\n deltas = depths[:, :, 1:] - depths[:, :, :-1]\n colors_mid = (colors[:, :, :-1] + colors[:, :, 1:]) / 2\n densities_mid = (densities[:, :, :-1] + densities[:, :, 1:]) / 2\n depths_mid = (depths[:, :, :-1] + depths[:, :, 1:]) / 2\n\n\n if rendering_options['clamp_mode'] == 'softplus':\n densities_mid = F.softplus(densities_mid - 1) # activation bias of -1 makes things initialize better\n else:\n assert False, \"MipRayMarcher only supports `clamp_mode`=`softplus`!\"\n\n density_delta = densities_mid * deltas\n\n alpha = 1 - torch.exp(-density_delta)\n\n alpha_shifted = torch.cat([torch.ones_like(alpha[:, :, :1]), 1-alpha + 1e-10], -2)\n weights = alpha * torch.cumprod(alpha_shifted, -2)[:, :, :-1]\n\n composite_rgb = torch.sum(weights * colors_mid, -2)\n weight_total = weights.sum(2)\n composite_depth = torch.sum(weights * depths_mid, -2) / weight_total\n\n # clip the composite to min/max range of depths\n composite_depth = torch.nan_to_num(composite_depth, float('inf'))\n composite_depth = torch.clamp(composite_depth, torch.min(depths), torch.max(depths))\n\n if rendering_options.get('white_back', False):\n composite_rgb = composite_rgb + 1 - weight_total\n\n composite_rgb = composite_rgb * 2 - 1 # Scale to (-1, 1)\n\n return composite_rgb, composite_depth, weights\n\n\n def forward(self, colors, densities, depths, rendering_options):\n composite_rgb, composite_depth, weights = self.run_forward(colors, densities, depths, rendering_options)\n\n return composite_rgb, composite_depth, weights" }, { "identifier": "math_utils", "path": "models/eg3d/volumetric_rendering/math_utils.py", "snippet": "def transform_vectors(matrix: torch.Tensor, vectors4: torch.Tensor) -> torch.Tensor:\ndef normalize_vecs(vectors: torch.Tensor) -> torch.Tensor:\ndef torch_dot(x: torch.Tensor, y: torch.Tensor):\ndef get_ray_limits_box(rays_o: torch.Tensor, rays_d: torch.Tensor, box_side_length):\ndef linspace(start: torch.Tensor, stop: torch.Tensor, num: int):" } ]

[ { "identifier": "ContactForm", "path": "personal_assistant/app_contacts/forms.py", "snippet": "class ContactForm(ModelForm):\n fullname = CharField(max_length=255, \n widget=forms.TextInput(attrs={'placeholder': 'Name Lastname', \"class\": \"form-control\"}))\n address = CharField(max_length=255, required=False, \n widget=forms.TextInput(attrs={'placeholder': 'City, Street, House number', \"class\": \"form-control\"}))\n birthday = DateField(required=False, input_formats=[\"%d.%m.%Y\"], \n widget=forms.DateInput(attrs={'placeholder': 'DD.MM.YYYY', 'class': 'form-control'}))\n class Meta:\n model = Contact\n fields = [\"fullname\", \"address\", \"birthday\"]\n exclude = [\"user\"]" }, { "identifier": "PhoneNumberForm", "path": "personal_assistant/app_contacts/forms.py", "snippet": "class PhoneNumberForm(forms.ModelForm):\n phone_number = PhoneNumberField(\n widget=PhoneNumberPrefixWidget(attrs={'placeholder': '+380', 'class': 'form-control'})\n )\n class Meta:\n model = PhoneNumber\n fields = [\"phone_number\"]\n exclude = [\"contact\"]" }, { "identifier": "EmailAddressForm", "path": "personal_assistant/app_contacts/forms.py", "snippet": "class EmailAddressForm(forms.ModelForm):\n email = EmailField(max_length=100, required=False, widget=forms.EmailInput(attrs={'placeholder': '[email protected]', 'class': 'form-control'}))\n\n class Meta:\n model = EmailAddress\n fields = [\"email\"]\n exclude = [\"contact\"]" }, { "identifier": "Contact", "path": "personal_assistant/app_contacts/models.py", "snippet": "class Contact(models.Model):\n fullname = models.CharField(max_length=255)\n address = models.CharField(max_length=255, blank=True, null=True)\n birthday = models.DateField(blank=True, null=True)\n user = models.ForeignKey(User, on_delete=models.CASCADE, null=True)" }, { "identifier": "PhoneNumber", "path": "personal_assistant/app_contacts/models.py", "snippet": "class PhoneNumber(models.Model):\n phone_number = PhoneNumberField(null=True,)\n contact = models.ForeignKey(\n Contact, on_delete=models.CASCADE, default=None, null=True, related_name='phone_numbers'\n )" }, { "identifier": "EmailAddress", "path": "personal_assistant/app_contacts/models.py", "snippet": "class EmailAddress(models.Model):\n email = models.EmailField(max_length=100, null=True)\n contact = models.ForeignKey(\n Contact, on_delete=models.CASCADE, default=None, null=True, related_name='email_addresses'\n )" } ]

[ { "identifier": "RandUserAgent", "path": "modules/convert/util.py", "snippet": "def RandUserAgent() -> str:\n return userAgents[random.randint(0, len(userAgents) - 1)]" }, { "identifier": "get", "path": "modules/convert/util.py", "snippet": "def get(content):\n if content is None:\n return \"\"\n else:\n return content" }, { "identifier": "uniqueName", "path": "modules/convert/util.py", "snippet": "def uniqueName(names: dict, name):\n\tindex = names.get(name)\n\tif index is None:\n\t\tindex = 0\n\t\tnames[name] = index\n\telse:\n\t\tindex += 1\n\t\tnames[name] = index\n\t\tname = \"%s-%02d\" % (name, index)\n\treturn name" }, { "identifier": "urlSafe", "path": "modules/convert/util.py", "snippet": "def urlSafe(string):\n\treturn string.replace(\"+\", \"-\").replace(\"/\", \"_\")" }, { "identifier": "base64RawStdDecode", "path": "modules/convert/util.py", "snippet": "def base64RawStdDecode(encoded):\n\treturn base64.b64decode(\n encoded + \"=\"*(-len(encoded)%4)\n\t).decode(\"utf-8\")" }, { "identifier": "base64RawURLDecode", "path": "modules/convert/util.py", "snippet": "def base64RawURLDecode(encoded):\n\treturn base64.urlsafe_b64decode(\n\t\t\t encoded + \"=\"*(-len(encoded)%4)\n\t).decode(\"utf-8\")" }, { "identifier": "handleVShareLink", "path": "modules/convert/v.py", "snippet": "def handleVShareLink(names: dict, url: urlparse.ParseResult, scheme: str, proxy: dict):\n query = dict(urlparse.parse_qsl(url.query))\n proxy[\"name\"] = uniqueName(names, urlparse.unquote(url.fragment))\n if url.hostname == \"\":\n raise\n if url.port == \"\":\n raise\n proxy[\"type\"] = scheme\n proxy[\"server\"] = url.hostname\n proxy[\"port\"] = url.port\n proxy[\"uuid\"] = url.username\n proxy[\"udp\"] = True\n tls = get(query.get(\"security\")).lower()\n if tls.endswith(\"tls\") or tls == \"reality\":\n proxy[\"tls\"] = True\n fingerprint = get(query.get(\"fp\"))\n if fingerprint == \"\":\n proxy[\"client-fingerprint\"] = \"chrome\"\n else:\n proxy[\"client-fingerprint\"] = fingerprint\n alpn = get(query.get(\"alpn\"))\n if alpn != \"\":\n proxy[\"alpn\"] = alpn.split(\",\")\n sni = get(query.get(\"sni\"))\n if sni != \"\":\n proxy[\"servername\"] = sni\n realityPublicKey = get(query.get(\"pbk\"))\n if realityPublicKey != \"\":\n proxy[\"reality-opts\"] = {\n \"public-key\": realityPublicKey,\n \"short-id\": get(query.get(\"sid\"))\n }\n \n switch = get(query.get(\"packetEncoding\"))\n if switch == \"none\" or switch == \"\":\n pass\n elif switch == \"packet\":\n proxy[\"packet-addr\"] = True\n else:\n proxy[\"xudp\"] = True\n\n network = get(query.get(\"type\")).lower()\n if network == \"\":\n network = \"tcp\"\n fakeType = get(query.get(\"headerType\")).lower()\n if fakeType == \"http\":\n network = \"http\"\n elif network == \"http\":\n network = \"h2\"\n proxy[\"network\"] = network\n if network == \"tcp\":\n if fakeType != \"none\" and fakeType != \"\":\n headers = {}\n httpOpts = {}\n httpOpts[\"path\"] = \"/\"\n\n host = get(query.get(\"host\"))\n if host != \"\":\n headers[\"Host\"] = str(host)\n\n method = get(query.get(\"method\"))\n if method != \"\":\n httpOpts[\"method\"] = method\n\n path = get(query.get(\"path\"))\n if path != \"\":\n httpOpts[\"path\"] = str(path)\n \n httpOpts[\"headers\"] = headers\n proxy[\"http-opts\"] = httpOpts\n\n elif network == \"http\":\n headers = {}\n h2Opts = {}\n h2Opts[\"path\"] = \"/\"\n path = get(query.get(\"path\"))\n if path != \"\":\n h2Opts[\"path\"] = str(path)\n host = get(query.get(\"host\"))\n if host != \"\":\n h2Opts[\"host\"] = str(host)\n h2Opts[\"headers\"] = headers\n proxy[\"h2-opts\"] = h2Opts\n \n elif network == \"ws\":\n headers = {}\n wsOpts = {}\n headers[\"User-Agent\"] = RandUserAgent()\n headers[\"Host\"] = get(query.get(\"host\"))\n wsOpts[\"path\"] = get(query.get(\"path\"))\n wsOpts[\"headers\"] = headers\n\n earlyData = get(query.get(\"ed\"))\n if earlyData != \"\":\n try:\n med = int(earlyData)\n except:\n raise\n wsOpts[\"max-early-data\"] = med\n earlyDataHeader = get(query.get(\"edh\"))\n if earlyDataHeader != \"\":\n wsOpts[\"early-data-header-name\"] = earlyDataHeader\n\n proxy[\"ws-opts\"] = wsOpts\n\n elif network == \"grpc\":\n grpcOpts = {}\n grpcOpts[\"grpc-service-name\"] = get(query.get(\"serviceName\"))\n proxy[\"grpc-opts\"] = grpcOpts" } ]

[ { "identifier": "NotRegistered", "path": "src/pyscipopt_ml/exceptions.py", "snippet": "class NotRegistered(Exception):\n \"\"\"Predictor is not supported by pyscipopt-ml.\"\"\"\n\n def __init__(self, predictor):\n super().__init__(\n f\"Object of type {predictor} is not registered/supported with pyscipopt-ml\"\n )" }, { "identifier": "get_convertor", "path": "src/pyscipopt_ml/modelling/get_convertor.py", "snippet": "def get_convertor(predictor, convertors):\n \"\"\"Return the convertor for a given predictor.\"\"\"\n convertor = None\n try:\n convertor = convertors[type(predictor)]\n except KeyError:\n pass\n if convertor is None:\n for parent in type(predictor).mro():\n try:\n convertor = convertors[parent]\n break\n except KeyError:\n pass\n if convertor is None:\n name = type(predictor).__name__\n try:\n convertor = convertors[name]\n except KeyError:\n pass\n return convertor" }, { "identifier": "registered_predictors", "path": "src/pyscipopt_ml/registered_predictors.py", "snippet": "def registered_predictors():\n \"\"\"Return the list of registered predictors.\"\"\"\n convertors = {\n **sklearn_convertors(),\n **pytorch_convertors(),\n **xgboost_convertors(),\n **lightgbm_convertors(),\n }\n return convertors" } ]

[ { "identifier": "Transformer", "path": "model.py", "snippet": "class Transformer(nn.Module):\n def __init__(self, config: ModelArgs) -> None:\n super().__init__()\n self.config = config\n\n self.tok_embeddings = nn.Embedding(config.vocab_size, config.dim)\n self.layers = nn.ModuleList(TransformerBlock(config) for _ in range(config.n_layer))\n self.norm = RMSNorm(config.dim, eps=config.norm_eps)\n self.output = nn.Linear(config.dim, config.vocab_size, bias=False)\n\n self.freqs_cis: Optional[Tensor] = None\n self.mask_cache: Optional[Tensor] = None\n self.max_batch_size = -1\n self.max_seq_length = -1\n\n def setup_caches(self, max_batch_size, max_seq_length):\n if self.max_seq_length >= max_seq_length and self.max_batch_size >= max_batch_size:\n return\n head_dim = self.config.dim // self.config.n_head\n max_seq_length = find_multiple(max_seq_length, 8)\n self.max_seq_length = max_seq_length\n self.max_batch_size = max_batch_size\n for b in self.layers:\n b.attention.kv_cache = KVCache(max_batch_size, max_seq_length, self.config.n_local_heads, head_dim)\n\n self.freqs_cis = precompute_freqs_cis(self.config.block_size, self.config.dim // self.config.n_head, self.config.rope_base)\n self.causal_mask = torch.tril(torch.ones(self.max_seq_length, self.max_seq_length, dtype=torch.bool))\n\n def forward(self, idx: Tensor, input_pos: Optional[Tensor] = None) -> Tensor:\n assert self.freqs_cis is not None, \"Caches must be initialized first\"\n mask = self.causal_mask[None, None, input_pos]\n freqs_cis = self.freqs_cis[input_pos]\n x = self.tok_embeddings(idx)\n\n for i, layer in enumerate(self.layers):\n x = layer(x, input_pos, freqs_cis, mask)\n x = self.norm(x)\n logits = self.output(x)\n return logits\n\n @classmethod\n def from_name(cls, name: str):\n return cls(ModelArgs.from_name(name))" }, { "identifier": "maybe_init_dist", "path": "tp.py", "snippet": "def maybe_init_dist() -> Optional[int]:\n try:\n # provided by torchrun\n rank = _get_rank()\n world_size = _get_world_size()\n\n if world_size < 2:\n # too few gpus to parallelize, tp is no-op\n return None\n except KeyError:\n # not run via torchrun, no-op\n return None\n\n dist.init_process_group(backend=\"nccl\", rank=rank, world_size=world_size)\n return rank" } ]

[ { "identifier": "Channel", "path": "channel/channel.py", "snippet": "class Channel(object):\n NOT_SUPPORT_REPLYTYPE = [ReplyType.VOICE, ReplyType.IMAGE]\n\n def startup(self):\n \"\"\"\n init channel\n \"\"\"\n raise NotImplementedError\n\n def handle_text(self, msg):\n \"\"\"\n process received msg\n :param msg: message object\n \"\"\"\n raise NotImplementedError\n\n # 统一的发送函数，每个Channel自行实现，根据reply的type字段发送不同类型的消息\n def send(self, reply: Reply, context: Context):\n \"\"\"\n send message to user\n :param msg: message content\n :param receiver: receiver channel account\n :return:\n \"\"\"\n raise NotImplementedError\n\n def build_reply_content(self, query, context: Context = None) -> Reply:\n return Bridge().fetch_reply_content(query, context)\n\n def build_voice_to_text(self, voice_file) -> Reply:\n return Bridge().fetch_voice_to_text(voice_file)\n\n def build_text_to_voice(self, text) -> Reply:\n return Bridge().fetch_text_to_voice(text)" }, { "identifier": "Dequeue", "path": "common/dequeue.py", "snippet": "class Dequeue(Queue):\n def putleft(self, item, block=True, timeout=None):\n with self.not_full:\n if self.maxsize > 0:\n if not block:\n if self._qsize() >= self.maxsize:\n raise Full\n elif timeout is None:\n while self._qsize() >= self.maxsize:\n self.not_full.wait()\n elif timeout < 0:\n raise ValueError(\"'timeout' must be a non-negative number\")\n else:\n endtime = time() + timeout\n while self._qsize() >= self.maxsize:\n remaining = endtime - time()\n if remaining <= 0.0:\n raise Full\n self.not_full.wait(remaining)\n self._putleft(item)\n self.unfinished_tasks += 1\n self.not_empty.notify()\n\n def putleft_nowait(self, item):\n return self.putleft(item, block=False)\n\n def _putleft(self, item):\n self.queue.appendleft(item)" }, { "identifier": "logger", "path": "common/log.py", "snippet": "def _reset_logger(log):\ndef _get_logger():" }, { "identifier": "conf", "path": "config.py", "snippet": "def conf():\n return config" } ]

[ { "identifier": "MLP", "path": "bams/models/mlp.py", "snippet": "class MLP(nn.Module):\n r\"\"\"Flexible Multi-layer perceptron model, with optional batchnorm layers.\n\n Args:\n hidden_layers (list): List of layer dimensions, from input layer to output\n layer. If first input size is -1, will use a lazy layer.\n bias (boolean, optional): If set to :obj:`True`, bias will be used in linear\n layers. (default: :obj:`True`).\n activation (torch.nn.Module, optional): Activation function. (default:\n :obj:`nn.ReLU`).\n batchnorm (boolean, optional): If set to :obj:`True`, batchnorm layers are\n added after each linear layer, before the activation (default:\n :obj:`False`).\n drop_last_nonlin (boolean, optional): If set to :obj:`True`, the last layer\n won't have activations or batchnorm layers. (default: :obj:`True`)\n\n Examples:\n >>> m = MLP([-1, 16, 64])\n MLP(\n (layers): Sequential(\n (0): LazyLinear(in_features=0, out_features=16, bias=True)\n (1): ReLU(inplace=True)\n (2): Linear(in_features=16, out_features=64, bias=True)\n )\n )\n \"\"\"\n\n def __init__(\n self,\n hidden_layers,\n *,\n bias=True,\n activation=nn.ReLU(True),\n batchnorm=False,\n drop_last_nonlin=True\n ):\n super().__init__()\n\n # build the layers\n layers = []\n for in_dim, out_dim in zip(hidden_layers[:-1], hidden_layers[1:]):\n if in_dim == -1:\n layers.append(nn.LazyLinear(out_dim, bias=bias and not batchnorm))\n else:\n layers.append(nn.Linear(in_dim, out_dim, bias=bias and not batchnorm))\n if batchnorm:\n layers.append(nn.BatchNorm1d(num_features=out_dim, momentum=0.99))\n # ayers.append(nn.LayerNorm(out_dim))\n if activation is not None:\n activation = nn.PReLU(1)\n layers.append(activation)\n\n # remove activation and/or batchnorm layers from the last block\n if drop_last_nonlin:\n remove_layers = -(int(activation is not None) + int(batchnorm))\n if remove_layers:\n layers = layers[:remove_layers]\n\n self.layers = nn.Sequential(*layers)\n self.out_dim = hidden_layers[-1]\n\n def forward(self, x):\n x = self.layers(x)\n return x\n\n def reset_parameters(self):\n for m in self.modules():\n if isinstance(m, nn.Linear):\n m.reset_parameters()" }, { "identifier": "TemporalConvNet", "path": "bams/models/tcn.py", "snippet": "class TemporalConvNet(nn.Module):\n def __init__(\n self,\n num_inputs,\n num_channels,\n kernel_size=2,\n num_layers_per_block=2,\n dropout=0.2,\n shift=0,\n dilation=2,\n ):\n super(TemporalConvNet, self).__init__()\n\n self.num_levels = len(num_channels)\n self.kernel_size = prepare_argument(kernel_size, self.num_levels)\n self.num_layers_per_block = prepare_argument(\n num_layers_per_block, self.num_levels\n )\n self.dilation = dilation\n self.feat_dim = num_channels[-1]\n layers = []\n for i in range(self.num_levels):\n dilation_size = dilation**i\n shift_ = shift if i == (self.num_levels - 1) else 0\n in_channels = num_inputs if i == 0 else num_channels[i - 1]\n out_channels = num_channels[i]\n kernel_size = self.kernel_size[i]\n num_layers_per_block = self.num_layers_per_block[i]\n layers += [\n TemporalBlock(\n in_channels,\n out_channels,\n kernel_size,\n stride=1,\n dilation=dilation_size,\n padding=(kernel_size - 1) * dilation_size,\n n_layers=num_layers_per_block,\n dropout=dropout,\n shift=shift_ * dilation_size,\n )\n ]\n\n self.network = nn.Sequential(*layers)\n\n @property\n def receptive_field(self):\n return compute_receiptive_field(\n kernel_size=self.kernel_size,\n num_blocks=self.num_levels,\n num_layers_per_block=self.num_layers_per_block,\n dilation=self.dilation,\n )\n\n def forward(self, x):\n x = rearrange(x, \"b l k -> b k l\")\n ret = self.network(x)\n ret = rearrange(ret, \"b k l -> b l k\")\n return ret" } ]

[ { "identifier": "Daoyu", "path": "Utility/sdoLogin/Daoyu.py", "snippet": "def dykey_encrypt(self):\ndef config_handler():\ndef initialize():\ndef get_guid(device_id, manuid):\ndef get_flowid(manuid, deviceid, sessionid, show_username):\ndef get_account_id_list(flowid, deviceid, manuid, sessionid, show_username):\ndef make_confirm(account_id, flowid, deviceid, manuid, sessionid, show_username):\ndef get_sub_account_key(flowid, manuid, deviceid, sessionid, show_username):\ndef get_temp_sessionid(main_key):\ndef get_sub_account_session(sub_account_key, temp_account_sessionid):" }, { "identifier": "daoyumall_sign", "path": "Utility/sqMall/daoyuBuildinMallSign.py", "snippet": "def daoyumall_sign(sub_session_id, account_id):\n \"\"\"\n 仅适用于叨鱼内的盛趣商城签到操作 PC端不适用\n :param sub_session_id: 子账号的Daoyukey值\n :param account_id: 子账号的AccountID\n :return: 0： 签到成功 1: 重复签到 2: 签到失败\n \"\"\"\n sign_url = 'https://sqmallservice.u.sdo.com/api/us/integration/checkIn'\n sign_data = {'merchantId': 1}\n sign_header = {\n 'authority': 'sqmallservice.u.sdo.com',\n 'method': 'PUT',\n 'scheme': 'https',\n 'qu-web-host': 'https://m.qu.sdo.com',\n 'qu-hardware-platform': '1',\n 'qu-software-platform': '2',\n 'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 DaoYu/9.3.3',\n 'content-type': 'application/x-www-form-urlencoded; charset=UTF-8',\n 'accept': 'application/json, text/javascript, */*; q=0.01',\n 'qu-deploy-platform': '4',\n 'qu-merchant-id': '1',\n 'origin': 'https://m.qu.sdo.com',\n 'x-requested-with': 'com.sdo.sdaccountkey',\n 'sec-fetch-site': 'same-site',\n 'sec-fetch-mode': 'cors',\n 'sec-fetch-dest': 'empty',\n 'referer': 'https://m.qu.sdo.com/',\n }\n sign_cookies = {\n 'sessionId': sub_session_id,\n 'direbmemllam': account_id,\n }\n sign_response = requests.put(sign_url, headers=sign_header, cookies=sign_cookies, data=sign_data, verify=False)\n sign_json = sign_response.json()\n if sign_json['resultMsg'] == 'SUCCESS':\n return 0\n elif sign_json['resultMsg'] == '今日已签到，请勿重复签到':\n return 1\n else:\n return 2" }, { "identifier": "daoyu_mall_balance", "path": "Utility/sqMall/daoyuBuildinMallBalance.py", "snippet": "def daoyu_mall_balance(session_id):\n \"\"\"\n 仅适用于叨鱼内部商城的查询签到积分 PC端不适用\n :param session_id: 子账号的Daoyukey值\n :return: 返回签到积分余额\n \"\"\"\n get_balance_url = 'https://sqmallservice.u.sdo.com/api/rs/member/integral/balance?merchantId=1'\n get_balance_header = {\n 'authority': 'sqmallservice.u.sdo.com',\n 'method': 'GET',\n 'scheme': 'https',\n 'pragma': 'no-cache',\n 'cache-control': 'no-cache',\n 'qu-deploy-platform': '4',\n 'accept': 'application/json, text/javascript, */*; q=0.01',\n 'qu-merchant-id': '1',\n 'qu-hardware-platform': '1',\n 'qu-software-platform': '2',\n 'user-agent': 'Mozilla/5.0 (iPhone; CPU iPhone OS 17_0 like Mac OS X) AppleWebKit/605.1.15 (KHTML, like Gecko) Mobile/15E148 DaoYu/9.3.3',\n 'qu-web-host': 'https://m.qu.sdo.com',\n 'origin': 'https://m.qu.sdo.com',\n 'x-requested-with': 'com.sdo.sdaccountkey',\n 'sec-fetch-site': 'same-site',\n 'sec-fetch-mode': 'cors',\n 'sec-fetch-dest': 'empty',\n 'referer': 'https://m.qu.sdo.com/',\n 'accept-encoding': 'gzip, deflate',\n 'accept-language': 'zh-CN,zh;q=0.9,en-US;q=0.8,en;q=0.7',\n }\n get_balance_cookies = {\n 'sessionId': session_id\n }\n get_balance_response = requests.get(get_balance_url, headers=get_balance_header, cookies=get_balance_cookies,\n verify=False)\n get_balance_json = get_balance_response.json()\n balance = get_balance_json['data']['balance']\n return balance" } ]

[ { "identifier": "SUBREDDITS", "path": "config/dicts.py", "snippet": "SUBREDDITS = {\n 'tifu': 'rss',\n 'confession': 'rss',\n 'relationship_advice': 'web',\n 'amitheasshole': 'rss'\n}" }, { "identifier": "setup_logger", "path": "utils/logger.py", "snippet": "def setup_logger(name, level=logging.INFO, emoji='⚙️'):\n \"\"\"To setup as many loggers as you want\"\"\"\n\n # Create handlers\n c_handler = logging.StreamHandler()\n c_handler.setLevel(level)\n\n # Create formatters and add it to handlers\n c_format = ColoredFormatter(emoji + ' | %(name)s | %(message)s')\n c_handler.setFormatter(c_format)\n\n # Add handlers to the logger\n logger = logging.getLogger(name)\n logger.setLevel(level)\n logger.addHandler(c_handler)\n\n return logger" }, { "identifier": "Post", "path": "models/post.py", "snippet": "class Post:\n \"\"\"\n A class representing a Reddit post.\n \"\"\"\n def __init__(self, title, author, subreddit, content, crawl_date):\n \"\"\"\n Initialize a Post object.\n\n :param title: The title of the post.\n :type title: str\n :param author: The author of the post.\n :type author: str\n :param subreddit: The subreddit of the post.\n :type subreddit: str\n :param content: The content of the post.\n :type content: str\n :param crawl_date: The date the post was crawled.\n :type crawl_date: datetime.datetime\n \n \"\"\"\n # Simple data stores\n self.author = author\n self.subreddit = subreddit\n self.crawl_date = crawl_date\n\n # Replace Reddit slang in title and content\n self.title = replace_words(title, REDDIT_SLANG)\n self.content = replace_words(content, REDDIT_SLANG)\n\n # Remove Age/Gender Reddit-typical tuples\n self.title = re.sub(r\"\\(?\\d{1,3}[mfMF]\\)?\", '', self.title).strip()\n self.content = re.sub(r\"\\(?\\d{1,3}[mfMF]\\)?\", '', self.content).strip()\n\n # Clean up potentially spammy fields\n self.author = self.author.replace('\\n', ' ').replace('\\t', ' ')\n self.author = re.sub(' +', ' ', self.author).strip()\n self.title = self.title.replace('\\n', ' ').replace('\\t', ' ')\n self.title = re.sub(' +', ' ', self.title).strip()\n self.content = self.content.replace('\\n', ' ').replace('\\t', ' ')\n self.content = re.sub(' +', ' ', self.content).strip()\n\n # Calculate hash from title + author + post\n self.hash = hashlib.sha256(\n str.encode(self.title) + str.encode(self.author) +\n str.encode(self.subreddit)\n ).hexdigest()\n\n # Shorten title and hash\n self.short_title = shorten_string(self.title)\n self.short_hash = shorten_hash(self.hash)\n\n # By default, we don't have a generated audio, subtitles or video yet\n self.audio = False\n self.subtitles = False\n self.video = False\n self.uploaded_youtube = False\n\n # Used for storing which platforms the post has been uploaded to\n self.posted_to = []\n\n def __str__(self, short=True) -> str:\n return f\"\"\"{self.hash}\n├── title: {self.title},\n├── author: {self.author},\n├── subreddit: {self.subreddit},\n├── content: {shorten_string(self.content, max_length=50) if short else self.content},\n└── crawl_date: {self.crawl_date})\"\"\"" } ]

[ { "identifier": "getCheckinList", "path": "checkinList.py", "snippet": "def getCheckinList(session, http_header, userInfo, today=True):\n try:\n url = serverUrl + \"/getQdKbList\"\n data = {\n 'sign': userInfo['sign'],\n 'userType': userInfo['userType'],\n 'userCode': userInfo['userCode'],\n 'unitCode': userInfo['unitCode'],\n 'userName': userInfo['userName'],\n 'roleCode': userInfo['roleCode'],\n 'bm': None,\n 'xyMc': userInfo['xy'],\n 'zy': userInfo['zy'],\n 'bj': userInfo['bj'],\n 'xsCc': userInfo['xsCc'],\n 'scene': 1,\n 'key': 1 if today else 2\n }\n res = session.post(url, data=data, headers=http_header).text\n res = json.loads(res)\n if res['status'] != 1:\n print('get Checkin list failed')\n raise Exception('get Checkin list failed')\n # print(res)\n return res['Rows']\n\n except:\n print(json.dumps({\n \"status\": \"failed\",\n \"reason\": \"Get checkin list failed\"\n }, indent=4))\n raise" }, { "identifier": "printCheckinList", "path": "checkinList.py", "snippet": "def printCheckinList(session, http_header, userInfo, today=True, type=\"签到\"):\n rows = getCheckinList(session, http_header, userInfo, today)\n for id, lesson in enumerate(rows):\n print(id)\n print('课程名称：', lesson['kcMc'])\n print('上课时间：', lesson['skSj'])\n print('签到发起情况：', lesson['qdQkMc'])\n print(\"签到情况：\", lesson['xsQdQkMc'] + ('' if lesson['xsQdQk'] == '0' else f\"({lesson['skXsStr']})\"))\n # print('\\n')\n try:\n ckid = int(input(\"请输入\" + type + \"课程的序号：\"))\n except:\n print('输入错误')\n raise Exception('输入错误')\n if ckid < 0 or ckid >= len(rows):\n print('输入错误')\n raise Exception('输入错误')\n return rows[ckid]" } ]

[ { "identifier": "config", "path": "kanaries_track/config.py", "snippet": "class Config:" }, { "identifier": "RequestClient", "path": "kanaries_track/request.py", "snippet": "class RequestClient:\n \"\"\"Client for sending events to kanaries-track server\"\"\"\n def __init__(\n self,\n *,\n host: str,\n auth_token: str,\n max_retries: int,\n timeout: int,\n verify: bool,\n proxy: Any\n ) -> None:\n self.host = host\n self.auth_token = auth_token\n self.max_retries = max_retries\n self.timeout = timeout\n self.verify = verify\n self.proxy = proxy\n self.session = Session()\n\n def _post(self, path: str, data: Dict[str, Any]) -> Response:\n \"\"\"Post data to url\"\"\"\n url = f\"{self.host}{path}\"\n\n @backoff.on_exception(\n backoff.expo,\n Exception,\n max_tries=self.max_retries,\n )\n def __post():\n return self.session.post(\n url,\n headers={\"Track-Key\": self.auth_token},\n json=data,\n timeout=self.timeout,\n verify=self.verify,\n proxies=self.proxy\n )\n\n return __post()\n\n def track(self, events: List[Dict[str, Any]]):\n \"\"\"Send events to kanaries-track server\"\"\"\n logger.debug(\"send requests to server, event count: %s\", len(events))\n try:\n resp = self._post(\"/ingest/track\", events)\n logger.debug(\"track resp: %s\", resp.text)\n except Exception as e:\n logger.error(\"Failed to send events to server: %s\", str(e))" } ]

[ { "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 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": "multilabel", "path": "src/engine/eval/multilabel.py", "snippet": "def get_continuous_ids(probe_labels: List[int]) -> Dict[int, int]:\ndef multihot(x: List[List[int]], nb_classes: int) -> np.ndarray:\ndef compute_map(\n scores: np.ndarray, multihot_targets: np.ndarray\n) -> Tuple[np.ndarray, np.ndarray, float, float]:\ndef compute_f1(\n multihot_targets: np.ndarray, scores: np.ndarray, threshold: float = 0.5\n) -> Tuple[float, float, float]:\ndef get_best_f1_scores(\n multihot_targets: np.ndarray, scores: np.ndarray, threshold_end: int\n) -> Dict[str, float]:" }, { "identifier": "singlelabel", "path": "src/engine/eval/singlelabel.py", "snippet": "def accuracy(y_probs, y_true):\ndef top_n_accuracy(y_probs, truths, n=1):\ndef compute_acc_auc(y_probs, y_true_ids):\ndef topks_correct(preds, labels, ks):\ndef topk_errors(preds, labels, ks):\ndef topk_accuracies(preds, labels, ks):" }, { "identifier": "logging", "path": "src/utils/logging.py", "snippet": "_FORMAT = \"[%(levelname)s: %(filename)s: %(lineno)4d]: %(message)s\"\ndef _suppress_print():\n def print_pass(*objects, sep=\" \", end=\"\\n\", file=sys.stdout, flush=False):\ndef _cached_log_stream(filename):\ndef setup_logging(\n num_gpu, num_shards, output=\"\", name=\"MOSA\", color=True):\ndef setup_single_logging(name, output=\"\"):\ndef get_logger(name):\ndef log_json_stats(stats, sort_keys=True):\n def __init__(self, *args, **kwargs):\n def formatMessage(self, record: logging.LogRecord) -> str:\nclass _ColorfulFormatter(logging.Formatter):" } ]

[ { "identifier": "setup_basic_logging_for_scripts", "path": "src/chemsense/vision/logging_configuration.py", "snippet": "def setup_basic_logging_for_scripts() -> None:\n \"\"\"Setup basic stdout logging for scripts.\"\"\"\n logging.basicConfig(\n stream=sys.stdout,\n level=logging.INFO,\n format=\"%(asctime)s - %(name)s - %(levelname)s - %(message)s\",\n )" }, { "identifier": "ENCODERS_REGISTRY", "path": "src/chemsense/vision/modeling/encoders.py", "snippet": "ENCODERS_REGISTRY = {\n \"mobilenetv2_35_96\": {\n \"processor\": AutoImageProcessor.from_pretrained(\"google/mobilenet_v2_0.35_96\"),\n \"model\": MobileNetV2Model.from_pretrained(\"google/mobilenet_v2_0.35_96\"),\n \"size\": 96,\n },\n \"mobilenetv2_100_224\": {\n \"processor\": AutoImageProcessor.from_pretrained(\"google/mobilenet_v2_1.0_224\"),\n \"model\": MobileNetV2Model.from_pretrained(\"google/mobilenet_v2_1.0_224\"),\n \"size\": 224,\n },\n \"mobilenetv2_140_224\": {\n \"processor\": AutoImageProcessor.from_pretrained(\"google/mobilenet_v2_1.4_224\"),\n \"model\": MobileNetV2Model.from_pretrained(\"google/mobilenet_v2_1.4_224\"),\n \"size\": 224,\n },\n \"resnet_18\": {\n \"processor\": AutoImageProcessor.from_pretrained(\"microsoft/resnet-18\"),\n \"model\": ResNetModel.from_pretrained(\"microsoft/resnet-18\"),\n \"size\": 224,\n },\n \"resnet_50\": {\n \"processor\": AutoImageProcessor.from_pretrained(\"microsoft/resnet-50\"),\n \"model\": ResNetModel.from_pretrained(\"microsoft/resnet-50\"),\n \"size\": 224,\n },\n \"resnet_101\": {\n \"processor\": AutoImageProcessor.from_pretrained(\"microsoft/resnet-101\"),\n \"model\": ResNetModel.from_pretrained(\"microsoft/resnet-101\"),\n \"size\": 224,\n },\n \"vit_base_224\": {\n \"processor\": ViTImageProcessor.from_pretrained(\"google/vit-base-patch16-224\"),\n \"model\": ViTModel.from_pretrained(\"google/vit-base-patch16-224\"),\n \"size\": 224,\n },\n \"vit_base_384\": {\n \"processor\": ViTImageProcessor.from_pretrained(\"google/vit-base-patch16-384\"),\n \"model\": ViTModel.from_pretrained(\"google/vit-base-patch16-384\"),\n \"size\": 384,\n },\n \"vit_large_224\": {\n \"processor\": ViTImageProcessor.from_pretrained(\"google/vit-large-patch16-224\"),\n \"model\": ViTModel.from_pretrained(\"google/vit-large-patch16-224\"),\n \"size\": 224,\n },\n \"beit_base_224\": {\n \"processor\": BeitImageProcessor.from_pretrained(\n \"microsoft/beit-base-patch16-224-pt22k-ft22k\"\n ),\n \"model\": BeitModel.from_pretrained(\n \"microsoft/beit-base-patch16-224-pt22k-ft22k\"\n ),\n \"size\": 224,\n },\n \"beit_base_384\": {\n \"processor\": BeitImageProcessor.from_pretrained(\n \"microsoft/beit-base-patch16-384\"\n ),\n \"model\": BeitModel.from_pretrained(\"microsoft/beit-base-patch16-384\"),\n \"size\": 384,\n },\n \"beit_large_224\": {\n \"processor\": BeitImageProcessor.from_pretrained(\n \"microsoft/beit-large-patch16-224-pt22k-ft22k\"\n ),\n \"model\": BeitModel.from_pretrained(\n \"microsoft/beit-large-patch16-224-pt22k-ft22k\"\n ),\n \"size\": 224,\n },\n}" } ]

[ { "identifier": "GoogleAIHandler", "path": "tinychat/llms/google.py", "snippet": "class GoogleAIHandler:\n \"\"\"\n Handler class to interact with the OpenAI models.\n\n Returns chat responses and stores the chat history.\n\n TODO: add chat message dataclass so that we can enforce validation of\n message format that is needed for working client requests to the API?\n \"\"\"\n\n def __init__(self):\n self._messages = []\n self._client = GoogleAIClient()\n \n def export_conversation(self) -> str:\n string_conversation = \"\"\n for message in self._messages:\n print(message)\n if message[\"role\"] == \"user\":\n if string_conversation != \"\":\n string_conversation += \"\\n\\n\"\n string_conversation += f\"You: {message['parts'][0]['text']}\"\n else:\n string_conversation += f\"LLM: {message['parts'][0]['text']}\"\n return string_conversation\n\n def stream_response(self, user_input: str) -> Generator[str, None, None]:\n \"\"\"\n Yield stream responses from the client as they are received.\n\n This method sends the user input to the client and then yields each piece\n of the language model's response as it is received in real-time. After the\n streaming is complete, it updates the message list with the user input and\n the full language model response.\n\n :param user_input: The input string from the user to be sent to the model.\n :return: A generator yielding the model's response in streamed parts.\n \"\"\"\n self._messages.append({\"parts\": [{\"text\": user_input}], \"role\": \"user\"})\n stream = self._client.perform_stream_request(self._messages)\n lm_response = \"\"\n for event in stream.events(): # type: ignore\n if event.data != \"[DONE]\":\n json_load = json.loads(event.data)[\"candidates\"][0][\"content\"][\"parts\"][0]\n response_piece = json_load[\"text\"]\n lm_response += response_piece\n yield response_piece\n self._messages.append({\"parts\": [{\"text\": lm_response}], \"role\": \"model\"})" }, { "identifier": "GoogleAIClient", "path": "tinychat/llms/google.py", "snippet": "class GoogleAIClient(BaseLLMClient):\n \"\"\"\n Simple client for interacting with the Google API.\n Currently only supports the chat completions endpoint.\n\n :param model_name: The name of the model to be used for chat requests.\n \"\"\"\n\n BASE_GEMINI_ENDPOINT = \"https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:streamGenerateContent\"\n SAFETY_SETTINGS = [\n {\n \"category\": \"HARM_CATEGORY_HARASSMENT\",\n \"threshold\": \"BLOCK_NONE\",\n },\n {\n \"category\": \"HARM_CATEGORY_HATE_SPEECH\",\n \"threshold\": \"BLOCK_NONE\",\n },\n {\n \"category\": \"HARM_CATEGORY_DANGEROUS_CONTENT\",\n \"threshold\": \"BLOCK_NONE\",\n },\n {\n \"category\": \"HARM_CATEGORY_SEXUALLY_EXPLICIT\",\n \"threshold\": \"BLOCK_NONE\",\n },\n ]\n\n def __init__(self) -> None:\n super().__init__(api_key_name=GOOGLE_API_KEY_NAME)\n\n @property\n def gemini_endpoint(self):\n return f\"{self.BASE_GEMINI_ENDPOINT}?alt=sse&key={self.api_key}\"\n\n @property\n def gemini_headers(self):\n return {\"Content-Type\": \"application/json\"}\n\n def perform_stream_request(self, messages: list[dict]) -> SSEClient:\n # info: https://developer.mozilla.org/en-US/docs/Web/API/Server-sent_events\n data = {\"contents\": messages, \"safetySettings\": self.SAFETY_SETTINGS}\n response = requests.post(\n self.gemini_endpoint,\n headers=self.gemini_headers, # type: ignore\n json=data,\n stream=True\n )\n if response.status_code != 200:\n raise ValueError(\n f\"Server responded with an error. Status Code: {response.status_code}\"\n )\n return SSEClient(event_source=response) # type: ignore" } ]

[ { "identifier": "_community_count_combinations", "path": "src/model/sampling.py", "snippet": "def _community_count_combinations(\n n_nodes: int, comm_counts: list[int]\n) -> Iterable[list[int]]:\n r\"\"\"Generate all possible community count vectors :math::`\\#`.\n\n Parameters\n ----------\n n_nodes: number of nodes in the hyperedges.\n comm_counts: list of community counts.\n The entry i of the list specifies the total number of nodes in community i in\n the full hypergraph.\n\n Yields\n -------\n All the possible vectors of community counts :math::`\\#`.\n \"\"\"\n K = len(comm_counts)\n\n yield from (\n counts\n for counts in _community_count_combinations_recursive(n_nodes, comm_counts)\n if len(counts) == K\n )" }, { "identifier": "_log_n_sharp", "path": "src/model/sampling.py", "snippet": "def _log_n_sharp(comm_counts: list[int], hye_comm_counts: list[int]) -> float:\n r\"\"\"compute the logarithm of the :math::`N_{\\#}` factor.\n\n Parameters\n ----------\n comm_counts: the number of nodes in every community of the hypergraph, as a list of\n length K, where K is the number of communities.\n hye_comm_counts: the number of nodes in the hyperedge contained in every community,\n as a list of length K.\n\n Returns\n -------\n The value of :math::`N_{\\#}`.\n \"\"\"\n if len(comm_counts) != len(hye_comm_counts):\n raise ValueError(\"The inputs have different lengths.\")\n return sum(\n log_binomial_coefficient(a, b) for a, b in zip(comm_counts, hye_comm_counts)\n )" }, { "identifier": "_sample_hye_from_count", "path": "src/model/sampling.py", "snippet": "def _sample_hye_from_count(\n comm_nodes: dict[int, np.ndarray],\n hye_comm_counts: list[int],\n rng: np.random.Generator | None,\n) -> tuple[int]:\n \"\"\"Sample a hyperedge given, for every community, the number of nodes in the\n hyperedge belonging to the community.\n\n Parameters\n ----------\n comm_nodes: dictionary specifying the nodes belonging to each community in the\n hypergraph.\n hye_comm_counts: list specifying at every entry i the number of nodes belonging to\n community i in the hyperedge to be sampled.\n rng: optional numpy random generator, to be utilized for sampling.\n\n Returns\n -------\n A hyperedge sampled satisfying hye_comm_counts.\n \"\"\"\n if rng is None:\n rng = np.random.default_rng()\n\n hye = []\n for comm, node_count in zip(comm_nodes, hye_comm_counts):\n new_nodes = list(rng.choice(comm_nodes[comm], size=node_count, replace=False))\n hye.extend(new_nodes)\n\n return tuple(sorted(map(int, hye)))" } ]

[ { "identifier": "CONFIG", "path": "chumweb/config.py", "snippet": "CONFIG = init_config()" }, { "identifier": "RemoteImage", "path": "chumweb/remote_image.py", "snippet": "class RemoteImage:\n \"\"\"\n An image located on a remote computer that can be downloaded locally\n\n Attributes:\n remote_url URL to the icon on a remote server\n local_url Path to locally cached (and scaled) version of the icon\n \"\"\"\n remote_url: str\n local_path: str | None = None\n\n def __init__(self, remote_url):\n self.remote_url = remote_url" } ]

[ { "identifier": "get_file_extension_from_url", "path": "Uploader/functions/help_ytdl.py", "snippet": "def get_file_extension_from_url(url):\n url_path = urlparse(url).path\n basename = os.path.basename(url_path)\n return basename.split(\".\")[-1]" }, { "identifier": "get_resolution", "path": "Uploader/functions/help_ytdl.py", "snippet": "def get_resolution(info_dict):\n if {\"width\", \"height\"} <= info_dict.keys():\n width = int(info_dict['width'])\n height = int(info_dict['height'])\n # https://support.google.com/youtube/answer/6375112\n elif info_dict['height'] == 1080:\n width = 1920\n height = 1080\n elif info_dict['height'] == 720:\n width = 1280\n height = 720\n elif info_dict['height'] == 480:\n width = 854\n height = 480\n elif info_dict['height'] == 360:\n width = 640\n height = 360\n elif info_dict['height'] == 240:\n width = 426\n height = 240\n return (width, height)" } ]

[ { "identifier": "resize", "path": "pixelformer/networks/utils.py", "snippet": "def resize(input,\n size=None,\n scale_factor=None,\n mode='nearest',\n align_corners=None,\n warning=True):\n if warning:\n if size is not None and align_corners:\n input_h, input_w = tuple(int(x) for x in input.shape[2:])\n output_h, output_w = tuple(int(x) for x in size)\n if output_h > input_h or output_w > output_h:\n if ((output_h > 1 and output_w > 1 and input_h > 1\n and input_w > 1) and (output_h - 1) % (input_h - 1)\n and (output_w - 1) % (input_w - 1)):\n warnings.warn(\n f'When align_corners={align_corners}, '\n 'the output would more aligned if '\n f'input size {(input_h, input_w)} is `x+1` and '\n f'out size {(output_h, output_w)} is `nx+1`')\n if isinstance(size, torch.Size):\n size = tuple(int(x) for x in size)\n return F.interpolate(input, size, scale_factor, mode, align_corners)" }, { "identifier": "normal_init", "path": "pixelformer/networks/utils.py", "snippet": "def normal_init(module, mean=0, std=1, bias=0):\n if hasattr(module, 'weight') and module.weight is not None:\n nn.init.normal_(module.weight, mean, std)\n if hasattr(module, 'bias') and module.bias is not None:\n nn.init.constant_(module.bias, bias)" } ]

[ { "identifier": "SuggestionBuffer", "path": "suggestionbuffer.py", "snippet": "class SuggestionBuffer:\n def __init__(self, capacity):\n self.buffer = deque(maxlen=capacity)\n\n def add(self, *args):\n self.buffer.append(args)\n\n def sample(self, batch_size):\n if len(self.buffer) > batch_size:\n return random.sample(self.buffer, batch_size)\n # else return None\n\n def latest(self):\n return [self.buffer[-1]]" }, { "identifier": "make_env", "path": "utils.py", "snippet": "def make_env(env_str, n_envs=1, **env_args):\n envs = []\n for _ in range(n_envs):\n def env_func():\n env = Monitor(gym.make(env_str, **env_args))\n env.seed(new_random_seed())\n return env\n\n envs.append(env_func)\n return DummyVecEnv(envs)" } ]

[ { "identifier": "Preference", "path": "users/models.py", "snippet": "class Preference(models.Model):\n class AIModels(models.TextChoices):\n GPT_3_5 = \"gpt-3.5-turbo\", \"GPT-3.5\"\n GEMINI_PRO = \"gemini-pro\", \"Gemini Pro\"\n\n SENTENCE_COUNT_CHOICES = tuple(zip(range(3, 11), range(3, 11)))\n\n user = models.OneToOneField(User, on_delete=models.CASCADE)\n ai_model = models.CharField(\n max_length=20, choices=AIModels, default=AIModels.GPT_3_5\n )\n sentence_count = models.IntegerField(default=5, choices=SENTENCE_COUNT_CHOICES)" }, { "identifier": "ArticleURLForm", "path": "url_summary/forms.py", "snippet": "class ArticleURLForm(forms.Form):\n url = forms.URLField(\n widget=forms.URLInput(\n attrs={\n \"type\": \"url\",\n \"class\": \"form-control\",\n \"placeholder\": \"Enter URL\",\n \"required\": True,\n \"autofocus\": True,\n \"maxlength\": 500,\n }\n ),\n )\n\n def clean_url(self):\n url = self.cleaned_data[\"url\"]\n if \"www.youtube.com\" in url:\n raise forms.ValidationError(\"Invalid Article URL.\")\n return url" }, { "identifier": "VideoURLForm", "path": "url_summary/forms.py", "snippet": "class VideoURLForm(forms.Form):\n url = forms.URLField(\n widget=forms.URLInput(\n attrs={\n \"type\": \"url\",\n \"class\": \"form-control\",\n \"placeholder\": \"Enter YouTube Video URL\",\n \"required\": True,\n \"autofocus\": True,\n \"maxlength\": 100,\n }\n ),\n )\n\n def clean_url(self):\n try:\n url = self.cleaned_data[\"url\"]\n if not url.startswith(\"https://www.youtube.com/watch?v=\"):\n raise\n\n # there may be other parameters in the URL\n video_id = url.split(\"v=\")[1].split(\"&\")[0]\n if len(video_id) != 11:\n raise\n except:\n video_id = None\n\n if not video_id:\n raise forms.ValidationError(\"Invalid YouTube URL.\")\n return url" }, { "identifier": "URLSummary", "path": "url_summary/models.py", "snippet": "class URLSummary(models.Model):\n \"\"\"A class representing URL summary results.\"\"\"\n\n url = models.URLField(max_length=500)\n title = models.CharField(max_length=250, blank=True)\n summary = models.TextField(blank=True)\n text = models.TextField(blank=True)\n created_at = models.DateTimeField(auto_now_add=True)\n bookmarks = models.ManyToManyField(\n settings.AUTH_USER_MODEL,\n related_name=\"bookmarked_summaries\",\n blank=True,\n )\n ai_model = models.CharField(\n max_length=20, choices=Preference.AIModels.choices, blank=True, null=True\n )\n\n class Meta:\n ordering = (\"-created_at\",)\n verbose_name = \"URL Summary\"\n\n def __str__(self) -> str:\n return f\"<URLSummary - {self.url}\"" }, { "identifier": "download_page", "path": "url_summary/utils/downloader.py", "snippet": "def download_page(url: str) -> tuple[requests.Response, bool]:\n \"\"\"Download HTML page from URL\"\"\"\n\n filename = \"user_agents.txt\"\n user_agents = get_user_agents(filename)\n error = False\n try:\n if user_agents:\n headers[\"user-agent\"] = user_agents[0]\n\n response = requests.get(url, headers=headers)\n response.raise_for_status()\n except Exception as e:\n print(e, response.status_code)\n error = True\n\n return response, error" } ]

[ { "identifier": "DetInferencer", "path": "mmdet/apis/det_inferencer.py", "snippet": " VOID = None\nIMG_EXTENSIONS = ('.jpg', '.jpeg', '.png', '.ppm', '.bmp', '.pgm', '.tif',\n '.tiff', '.webp')\nclass DetInferencer(BaseInferencer):\n def __init__(self,\n model: Optional[Union[ModelType, str]] = None,\n weights: Optional[str] = None,\n device: Optional[str] = None,\n scope: Optional[str] = 'mmdet',\n palette: str = 'none',\n show_progress: bool = True) -> None:\n def _load_weights_to_model(self, model: nn.Module,\n checkpoint: Optional[dict],\n cfg: Optional[ConfigType]) -> None:\n def _init_pipeline(self, cfg: ConfigType) -> Compose:\n def _get_transform_idx(self, pipeline_cfg: ConfigType,\n name: Union[str, Tuple[str, type]]) -> int:\n def _init_visualizer(self, cfg: ConfigType) -> Optional[Visualizer]:\n def _inputs_to_list(self, inputs: InputsType) -> list:\n def preprocess(self, inputs: InputsType, batch_size: int = 1, **kwargs):\n def _get_chunk_data(self, inputs: Iterable, chunk_size: int):\n def __call__(\n self,\n inputs: InputsType,\n batch_size: int = 1,\n return_vis: bool = False,\n show: bool = False,\n wait_time: int = 0,\n no_save_vis: bool = False,\n draw_pred: bool = True,\n pred_score_thr: float = 0.3,\n return_datasamples: bool = False,\n print_result: bool = False,\n no_save_pred: bool = True,\n out_dir: str = '',\n # by open image task\n texts: Optional[Union[str, list]] = None,\n # by open panoptic task\n stuff_texts: Optional[Union[str, list]] = None,\n # by GLIP\n custom_entities: bool = False,\n **kwargs) -> dict:\n def visualize(self,\n inputs: InputsType,\n preds: PredType,\n return_vis: bool = False,\n show: bool = False,\n wait_time: int = 0,\n draw_pred: bool = True,\n pred_score_thr: float = 0.3,\n no_save_vis: bool = False,\n img_out_dir: str = '',\n **kwargs) -> Union[List[np.ndarray], None]:\n def postprocess(\n self,\n preds: PredType,\n visualization: Optional[List[np.ndarray]] = None,\n return_datasamples: bool = False,\n print_result: bool = False,\n no_save_pred: bool = False,\n pred_out_dir: str = '',\n **kwargs,\n ) -> Dict:\n def pred2dict(self,\n data_sample: DetDataSample,\n pred_out_dir: str = '') -> Dict:" }, { "identifier": "ConfigType", "path": "mmdet/utils/typing_utils.py", "snippet": "" } ]

[ { "identifier": "BaseHFModel", "path": "src/maite/_internals/interop/huggingface/base.py", "snippet": "class BaseHFModel(nn.Module, BaseModel):\n def __init__(\n self,\n model_name: str,\n model: Union[HuggingFaceWithLogits, HuggingFaceWithDetection],\n processor: Optional[HuggingFaceProcessor] = None,\n post_processor: Optional[HuggingFaceObjectDetectionPostProcessor] = None,\n ) -> None:\n def get_labels(self) -> Sequence[str]:" }, { "identifier": "HuggingFacePredictions", "path": "src/maite/_internals/interop/huggingface/typing.py", "snippet": "class HuggingFacePredictions:\n scores: Tensor\n labels: Optional[Union[Tensor, Sequence[Sequence[str]]]] = None" }, { "identifier": "HuggingFaceProbs", "path": "src/maite/_internals/interop/huggingface/typing.py", "snippet": "class HuggingFaceProbs:\n probs: Tensor" }, { "identifier": "HuggingFaceProcessor", "path": "src/maite/_internals/interop/huggingface/typing.py", "snippet": "class HuggingFaceProcessor(Protocol):\n def __call__(\n self,\n images: Sequence[ArrayLike],\n return_tensors: Union[bool, str] = False,\n **kwargs: Any,\n ) -> BatchFeature:\n ..." }, { "identifier": "HuggingFaceWithLogits", "path": "src/maite/_internals/interop/huggingface/typing.py", "snippet": "class HuggingFaceWithLogits(HuggingFaceModule, Protocol):\n def __call__(\n self, pixel_values: Union[ArrayLike, Sequence[ArrayLike]], **kwargs: Any\n ) -> HasLogits:\n ..." } ]

[ { "identifier": "Provider", "path": "src/shelloracle/provider.py", "snippet": "class Provider(Protocol):\n \"\"\"\n LLM Provider Protocol\n\n All LLM backends must implement this interface.\n \"\"\"\n name: str\n\n @abstractmethod\n def generate(self, prompt: str) -> AsyncIterator[str]:\n \"\"\"\n This is an asynchronous generator method which defines the protocol that a provider implementation\n should adhere to. The method takes a prompt as an argument and produces an asynchronous stream\n of string results.\n\n :param prompt: A string value which serves as input to the provider's process of generating results.\n :return: An asynchronous generator yielding string results.\n \"\"\"\n # If you are wondering why the 'generate' signature doesn't include 'async', see\n # https://mypy.readthedocs.io/en/stable/more_types.html#asynchronous-iterators" }, { "identifier": "ProviderError", "path": "src/shelloracle/provider.py", "snippet": "class ProviderError(Exception):\n \"\"\"LLM providers raise this error to gracefully indicate something has gone wrong.\"\"\"" }, { "identifier": "Setting", "path": "src/shelloracle/config/setting.py", "snippet": "class Setting(Generic[T]):\n def __init__(self, *, name: str | None = None, default: T | None = None) -> None:\n self.name = name\n self.default = default\n\n def __set_name__(self, owner: type[Provider], name: str) -> None:\n if not self.name:\n self.name = name\n # Set the default value in the config dictionary if it doesn't exist\n provider_table = config.global_config.get(\"provider\", {})\n provider_table.setdefault(owner.name, {}).setdefault(name, self.default)\n config.global_config[\"provider\"] = provider_table\n\n def __get__(self, instance: Provider, owner: type[Provider]) -> T:\n return config.global_config.get(\"provider\", {}).get(instance.name, {})[self.name]\n\n def __set__(self, instance: Provider, value: T) -> None:\n config.global_config.setdefault(\"provider\", {}).setdefault(instance.name, {})[self.name] = value" } ]

[ { "identifier": "LOG_FILE", "path": "settings.py", "snippet": "LOG_FILE = \"packetirc.log\"" }, { "identifier": "LOG_LEVEL", "path": "settings.py", "snippet": "LOG_LEVEL = logging.INFO" }, { "identifier": "SERVER", "path": "settings.py", "snippet": "SERVER = \"\"" }, { "identifier": "PORT", "path": "settings.py", "snippet": "PORT = 6667" }, { "identifier": "PASS", "path": "settings.py", "snippet": "PASS = \"\"" }, { "identifier": "CHANNEL", "path": "settings.py", "snippet": "CHANNEL = \"#Testing\"" }, { "identifier": "HIDE_SERVER", "path": "settings.py", "snippet": "HIDE_SERVER = True" }, { "identifier": "MAX_RETRIES", "path": "settings.py", "snippet": "MAX_RETRIES = 3" }, { "identifier": "RETRY_DELAY", "path": "settings.py", "snippet": "RETRY_DELAY = 5 # seconds" }, { "identifier": "HELP_INFO", "path": "settings.py", "snippet": "HELP_INFO = \"\"\"\nPacketIRC commands:\n /quit [message] - Disconnect from the server with optional message.\n /msg <nickname> <message> - Send a private message to the specified user.\n /join <channel> - Join the specified channel.\n /names - Shows a list of users in the channel.\n /topic [new topic] - Set a new topic for the current channel or request the topic.\n /away [message] - Set an away message or clear the away status.\n /whois <nickname> - Retrieves information about the specified user.\n /help - Display this help message.\n\"\"\"" }, { "identifier": "WELCOME_MESSAGE", "path": "settings.py", "snippet": "WELCOME_MESSAGE = \"\"\"\nWelcome to PacketIRC!\nType /help for a list of commands.\n\"\"\"" }, { "identifier": "BAD_WORDS_FILE", "path": "settings.py", "snippet": "BAD_WORDS_FILE = \"bad_words.txt\"" }, { "identifier": "BAD_WORDS_FILTER", "path": "settings.py", "snippet": "BAD_WORDS_FILTER = False" } ]

[ { "identifier": "commons", "path": "onnxlib/commons.py", "snippet": "def init_weights(m, mean=0.0, std=0.01):\ndef get_padding(kernel_size, dilation=1):\ndef kl_divergence(m_p, logs_p, m_q, logs_q):\ndef rand_gumbel(shape):\ndef rand_gumbel_like(x):\ndef slice_segments(x, ids_str, segment_size=4):\ndef slice_segments2(x, ids_str, segment_size=4):\ndef rand_slice_segments(x, x_lengths=None, segment_size=4):\ndef get_timing_signal_1d(length, channels, min_timescale=1.0, max_timescale=1.0e4):\ndef add_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4):\ndef cat_timing_signal_1d(x, min_timescale=1.0, max_timescale=1.0e4, axis=1):\ndef subsequent_mask(length):\ndef fused_add_tanh_sigmoid_multiply(input_a, input_b, n_channels):\ndef convert_pad_shape(pad_shape: List[List[int]]) -> List[int]:\ndef shift_1d(x):\ndef sequence_mask(length: torch.Tensor, max_length: Optional[int] = None):\ndef generate_path(duration, mask):\ndef clip_grad_value_(parameters, clip_value, norm_type=2):" }, { "identifier": "modules", "path": "onnxlib/modules.py", "snippet": "LRELU_SLOPE = 0.1\nclass LayerNorm(nn.Module):\nclass ConvReluNorm(nn.Module):\nclass DDSConv(nn.Module):\nclass WN(torch.nn.Module):\nclass ResBlock1(torch.nn.Module):\nclass ResBlock2(torch.nn.Module):\nclass Log(nn.Module):\nclass Flip(nn.Module):\nclass ElementwiseAffine(nn.Module):\nclass ResidualCouplingLayer(nn.Module):\nclass ConvFlow(nn.Module):\n def __init__(self, channels, eps=1e-5):\n def forward(self, x):\n def __init__(\n self,\n in_channels,\n hidden_channels,\n out_channels,\n kernel_size,\n n_layers,\n p_dropout,\n ):\n def forward(self, x, x_mask):\n def __init__(self, channels, kernel_size, n_layers, p_dropout=0.0):\n def forward(self, x, x_mask, g: Optional[torch.Tensor] = None):\n def __init__(\n self,\n hidden_channels,\n kernel_size,\n dilation_rate,\n n_layers,\n gin_channels=0,\n p_dropout=0,\n ):\n def forward(\n self, x: torch.Tensor, x_mask: torch.Tensor, g: Optional[torch.Tensor] = None\n ):\n def remove_weight_norm(self):\n def __prepare_scriptable__(self):\n def __init__(self, channels, kernel_size=3, dilation=(1, 3, 5)):\n def forward(self, x: torch.Tensor, x_mask: Optional[torch.Tensor] = None):\n def remove_weight_norm(self):\n def __prepare_scriptable__(self):\n def __init__(self, channels, kernel_size=3, dilation=(1, 3)):\n def forward(self, x, x_mask: Optional[torch.Tensor] = None):\n def remove_weight_norm(self):\n def __prepare_scriptable__(self):\n def forward(\n self,\n x: torch.Tensor,\n x_mask: torch.Tensor,\n g: Optional[torch.Tensor] = None,\n reverse: bool = False,\n ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:\n def forward(\n self,\n x: torch.Tensor,\n x_mask: torch.Tensor,\n g: Optional[torch.Tensor] = None,\n reverse: bool = False,\n ) -> Tuple[torch.Tensor, Optional[torch.Tensor]]:\n def __init__(self, channels):\n def forward(self, x, x_mask, reverse=False, **kwargs):\n def __init__(\n self,\n channels,\n hidden_channels,\n kernel_size,\n dilation_rate,\n n_layers,\n p_dropout=0,\n gin_channels=0,\n mean_only=False,\n ):\n def forward(\n self,\n x: torch.Tensor,\n x_mask: torch.Tensor,\n g: Optional[torch.Tensor] = None,\n reverse: bool = False,\n ):\n def remove_weight_norm(self):\n def __prepare_scriptable__(self):\n def __init__(\n self,\n in_channels,\n filter_channels,\n kernel_size,\n n_layers,\n num_bins=10,\n tail_bound=5.0,\n ):\n def forward(\n self,\n x: torch.Tensor,\n x_mask: torch.Tensor,\n g: Optional[torch.Tensor] = None,\n reverse=False,\n ):" }, { "identifier": "LayerNorm", "path": "onnxlib/modules.py", "snippet": "class LayerNorm(nn.Module):\n def __init__(self, channels, eps=1e-5):\n super(LayerNorm, self).__init__()\n self.channels = channels\n self.eps = eps\n\n self.gamma = nn.Parameter(torch.ones(channels))\n self.beta = nn.Parameter(torch.zeros(channels))\n\n def forward(self, x):\n x = x.transpose(1, -1)\n x = F.layer_norm(x, (self.channels,), self.gamma, self.beta, self.eps)\n return x.transpose(1, -1)" } ]

[ { "identifier": "DefaultToken", "path": "utils_data/default_tokens.py", "snippet": "class DefaultToken(Enum):\n PAD_TOKEN = \"[PAD]\"\n EOS_TOKEN = \"</s>\"\n BOS_TOKEN = \"<s>\"\n UNK_TOKEN = \"<unk>\"\n IGNORE_INDEX = -100" }, { "identifier": "partition_idx_labeldir", "path": "utils_data/partition_data.py", "snippet": "def partition_idx_labeldir(y, n_parties, alpha, num_classes):\n min_size = 0\n min_require_size = 10\n K = num_classes\n N = y.shape[0]\n net_dataidx_map = {}\n\n while min_size < min_require_size:\n idx_batch = [[] for _ in range(n_parties)]\n for k in range(K):\n idx_k = np.where(y == k)[0]\n np.random.shuffle(idx_k)\n proportions = np.random.dirichlet(np.repeat(alpha, n_parties))\n # Balance\n proportions = np.array([p * (len(idx_j) < N / n_parties) for p, idx_j in zip(proportions, idx_batch)])\n proportions = proportions / proportions.sum()\n proportions = (np.cumsum(proportions) * len(idx_k)).astype(int)[:-1]\n idx_batch = [idx_j + idx.tolist() for idx_j, idx in zip(idx_batch, np.split(idx_k, proportions))]\n min_size = min([len(idx_j) for idx_j in idx_batch])\n for j in range(n_parties):\n np.random.shuffle(idx_batch[j])\n net_dataidx_map[j] = idx_batch[j]\n return net_dataidx_map" } ]

[ { "identifier": "get_logger", "path": "pixpnet/utils.py", "snippet": "def get_logger(name):\n logging.basicConfig(\n format=\"%(asctime)s[%(process)d][%(levelname)s] %(message)s\",\n datefmt=\"%Y-%m-%dT%H:%M:%S\",\n )\n logger = logging.getLogger(name)\n logger.setLevel(os.environ.get(\"PIXPNET_LOG_LEVEL\", \"INFO\"))\n return logger" }, { "identifier": "intersect_func_and_kwargs", "path": "pixpnet/utils.py", "snippet": "def intersect_func_and_kwargs(func, kwargs, exclude_func_args=None, exclude_kwargs=None, return_invalid=True):\n func_args = {*get_all_func_args(func)} - (set() if exclude_func_args is None else {*exclude_func_args})\n if isinstance(kwargs, argparse.Namespace):\n kwargs = vars(kwargs)\n kwargs_keys = {*kwargs.keys()} - (set() if exclude_kwargs is None else {*exclude_kwargs})\n\n intersecting_keys = kwargs_keys & func_args\n intersected_dict = {k: kwargs[k] for k in intersecting_keys}\n if return_invalid:\n return intersected_dict, kwargs_keys - func_args\n return intersected_dict" } ]

[ { "identifier": "get_default_config", "path": "megraph/io_utils.py", "snippet": "def get_default_config(args):\n dataset_name = args.dataset_name\n dataset_subname = args.dataset_subname\n model_name = args.model\n conv_name = args.layer\n\n # Config\n cfg_file = args.config_file\n if cfg_file is not None:\n config = read_config_file(cfg_file)\n if config is None:\n cfg_file = None\n print(\n f\"[Warning] Could not found {cfg_file}, \"\n \"fall back to default config files.\"\n )\n else:\n config[\"config_file\"] = cfg_file\n if cfg_file is None:\n cfg_files = get_default_config_filenames(\n model_name, conv_name, dataset_name, dataset_subname\n )\n config = {}\n found_files = []\n for f in cfg_files:\n new_config = read_config_file(f, folder=args.configs_dir)\n if new_config is not None:\n print(f\"Overwrite default config using {f}:\")\n print(new_config)\n config.update(new_config)\n found_files.append(f)\n config[\"config_file\"] = found_files\n return config" }, { "identifier": "get_raw_cmdline", "path": "megraph/io_utils.py", "snippet": "def get_raw_cmdline():\n with open(\"/proc/self/cmdline\") as f:\n x = f.readlines()\n if x is None or len(x) == 0:\n return None\n return x[0].replace(\"\\x00\", \" \")" } ]

[ { "identifier": "train_baseline", "path": "train/train_baseline.py", "snippet": "def train(cfg):\ndef train_explain(cfg):" }, { "identifier": "train_gnn", "path": "train/train_gnn.py", "snippet": "def train(cfg):" }, { "identifier": "train_hgn", "path": "train/train_hgn.py", "snippet": "def train(cfg):" } ]

[ { "identifier": "nested_flatten", "path": "src/utils.py", "snippet": "def nested_flatten(t):\n \"\"\"\n Turn nested list/tuple/dict into a flat iterator.\n \"\"\"\n if isinstance(t, (list, tuple)):\n for x in t:\n yield from nested_flatten(x)\n elif isinstance(t, dict):\n for k, v in sorted(t.items()):\n yield from nested_flatten(v)\n else:\n yield t" }, { "identifier": "nested_pack", "path": "src/utils.py", "snippet": "def nested_pack(flat, structure):\n \"\"\"\n Restore nested structure from flattened state\n :param flat: result of nested_flatten\n :param structure: used as example when recovering structure\n :returns: nested structure like :structure: filled with elements of :flat:\n \"\"\"\n return _nested_pack(iter(flat), structure)" } ]

[ { "identifier": "preprocess", "path": "osprey/train/train.py", "snippet": "def preprocess(\n sources: Sequence[str],\n tokenizer: transformers.PreTrainedTokenizer,\n has_image: bool = False\n) -> Dict:\n \"\"\"\n Given a list of sources, each is a conversation list. This transform:\n 1. Add signal '### ' at the beginning each sentence, with end signal '\\n';\n 2. Concatenate conversations together;\n 3. Tokenize the concatenated conversation;\n 4. Make a deepcopy as the target. Mask human words with IGNORE_INDEX.\n \"\"\"\n if conversation_lib.default_conversation.sep_style == conversation_lib.SeparatorStyle.PLAIN:\n return preprocess_plain(sources, tokenizer)\n if conversation_lib.default_conversation.sep_style == conversation_lib.SeparatorStyle.LLAMA_2:\n return preprocess_llama_2(sources, tokenizer, has_image=has_image)\n if conversation_lib.default_conversation.version.startswith(\"v1\"):\n return preprocess_v1(sources, tokenizer, has_image=has_image)\n # add end signal and concatenate together\n conversations = []\n for source in sources:\n header = f\"{conversation_lib.default_conversation.system}\\n\\n\"\n conversation = _add_speaker_and_signal(header, source)\n conversations.append(conversation)\n # tokenize conversations\n def get_tokenize_len(prompts):\n return [len(tokenizer_image_token(prompt, tokenizer)) for prompt in prompts]\n\n if has_image:\n input_ids = [tokenizer_image_token(prompt, tokenizer, return_tensors='pt') for prompt in conversations]\n else:\n conversations_tokenized = _tokenize_fn(conversations, tokenizer)\n input_ids = conversations_tokenized[\"input_ids\"]\n\n targets = copy.deepcopy(input_ids)\n for target, source in zip(targets, sources):\n if has_image:\n tokenized_lens = get_tokenize_len([header] + [s[\"value\"] for s in source])\n else:\n tokenized_lens = _tokenize_fn([header] + [s[\"value\"] for s in source], tokenizer)[\"input_ids_lens\"]\n speakers = [sentence[\"from\"] for sentence in source]\n _mask_targets(target, tokenized_lens, speakers)\n\n return dict(input_ids=input_ids, labels=targets)" }, { "identifier": "preprocess_multimodal", "path": "osprey/train/train.py", "snippet": "def preprocess_multimodal(\n sources: Sequence[str],\n data_args: DataArguments,\n cur_token_len: int = 0\n) -> Dict:\n\n for source in sources:\n for sentence in source:\n if DEFAULT_IMAGE_TOKEN in sentence['value']:\n sentence['value'] = sentence['value'].replace(DEFAULT_IMAGE_TOKEN, '').strip()\n sentence['value'] = DEFAULT_IMAGE_TOKEN + '\\n' + sentence['value']\n sentence['value'] = sentence['value'].strip()\n if \"mmtag\" in conversation_lib.default_conversation.version:\n sentence['value'] = sentence['value'].replace(DEFAULT_IMAGE_TOKEN, '<Image>' + DEFAULT_IMAGE_TOKEN + '</Image>')\n replace_token = DEFAULT_IMAGE_TOKEN\n if data_args.mm_use_im_start_end:\n replace_token = DEFAULT_IM_START_TOKEN + replace_token + DEFAULT_IM_END_TOKEN\n sentence[\"value\"] = sentence[\"value\"].replace(DEFAULT_IMAGE_TOKEN, replace_token)\n\n return sources" } ]

[ { "identifier": "zero_rank_print", "path": "animatediff/utils/util.py", "snippet": "def zero_rank_print(s):\n if (not dist.is_initialized()) or (dist.is_initialized() and dist.get_rank() == 0): print(\"### \" + s)" }, { "identifier": "detect_edges", "path": "animatediff/utils/util.py", "snippet": "def detect_edges(lum: np.ndarray) -> np.ndarray:\n \"\"\"Detect edges using the luma channel of a frame.\n\n Arguments:\n lum: 2D 8-bit image representing the luma channel of a frame.\n\n Returns:\n 2D 8-bit image of the same size as the input, where pixels with values of 255\n represent edges, and all other pixels are 0.\n \"\"\"\n # Initialize kernel.\n kernel_size = estimated_kernel_size(lum.shape[1], lum.shape[0])\n kernel = np.ones((kernel_size, kernel_size), np.uint8)\n\n # Estimate levels for thresholding.\n # TODO(0.6.3): Add config file entries for sigma, aperture/kernel size, etc.\n sigma: float = 1.0 / 3.0\n median = np.median(lum)\n low = int(max(0, (1.0 - sigma) * median))\n high = int(min(255, (1.0 + sigma) * median))\n\n # Calculate edges using Canny algorithm, and reduce noise by dilating the edges.\n # This increases edge overlap leading to improved robustness against noise and slow\n # camera movement. Note that very large kernel sizes can negatively affect accuracy.\n edges = cv2.Canny(lum, low, high)\n return cv2.dilate(edges, kernel)" } ]

[ { "identifier": "batch_inference", "path": "texify/inference.py", "snippet": "def batch_inference(images, model, processor, temperature=settings.TEMPERATURE, max_tokens=settings.MAX_TOKENS):\n images = [image.convert(\"RGB\") for image in images]\n encodings = processor(images=images, return_tensors=\"pt\", add_special_tokens=False)\n pixel_values = encodings[\"pixel_values\"].to(model.dtype)\n pixel_values = pixel_values.to(model.device)\n\n additional_kwargs = {}\n if temperature > 0:\n additional_kwargs[\"temperature\"] = temperature\n additional_kwargs[\"do_sample\"] = True\n additional_kwargs[\"top_p\"] = 0.95\n\n generated_ids = model.generate(\n pixel_values=pixel_values,\n max_new_tokens=max_tokens,\n decoder_start_token_id=processor.tokenizer.bos_token_id,\n **additional_kwargs,\n )\n\n generated_text = processor.tokenizer.batch_decode(generated_ids, skip_special_tokens=True)\n generated_text = [postprocess(text) for text in generated_text]\n return generated_text" }, { "identifier": "load_model", "path": "texify/model/model.py", "snippet": "def load_model(checkpoint=settings.MODEL_CHECKPOINT, device=settings.TORCH_DEVICE_MODEL, dtype=settings.MODEL_DTYPE):\n config = get_config(checkpoint)\n AutoModel.register(VariableDonutSwinConfig, VariableDonutSwinModel)\n\n model = VisionEncoderDecoderModel.from_pretrained(checkpoint, config=config, torch_dtype=dtype)\n model = model.to(device)\n model = model.eval()\n print(f\"Loaded texify model to {device} with {dtype} dtype\")\n return model" }, { "identifier": "load_processor", "path": "texify/model/processor.py", "snippet": "def load_processor():\n AutoImageProcessor.register(VariableDonutSwinConfig, VariableDonutImageProcessor)\n processor = VariableDonutProcessor.from_pretrained(settings.MODEL_CHECKPOINT)\n processor.image_processor.max_size = settings.MAX_IMAGE_SIZE\n processor.image_processor.size = [settings.MAX_IMAGE_SIZE[\"height\"], settings.MAX_IMAGE_SIZE[\"width\"]]\n processor.image_processor.image_mean = IMAGE_MEAN\n processor.image_processor.image_std = IMAGE_STD\n processor.image_processor.train = False\n\n processor.tokenizer.model_max_length = settings.MAX_TOKENS\n processor.train = False\n return processor" }, { "identifier": "replace_katex_invalid", "path": "texify/output.py", "snippet": "def replace_katex_invalid(string):\n # KaTeX cannot render all LaTeX, so we need to replace some things\n string = re.sub(r'\\\\tag\\{.*?\\}', '', string)\n string = re.sub(r'\\\\(?:Bigg?|bigg?)\\{(.*?)\\}', r'\\1', string)\n string = re.sub(r'\\\\quad\\\\mbox\\{(.*?)\\}', r'\\1', string)\n string = re.sub(r'\\\\mbox\\{(.*?)\\}', r'\\1', string)\n string = remove_inner_dollars(string)\n return string" }, { "identifier": "settings", "path": "texify/settings.py", "snippet": "class Settings(BaseSettings):\n class Config:\n TORCH_DEVICE: Optional[str] = None\n MAX_TOKENS: int = 384 # Will not work well above 768, since it was not trained with more\n MAX_IMAGE_SIZE: Dict = {\"height\": 420, \"width\": 420}\n MODEL_CHECKPOINT: str = \"vikp/texify\"\n BATCH_SIZE: int = 16 # Should use ~5GB of RAM\n DATA_DIR: str = \"data\"\n TEMPERATURE: float = 0.0 # Temperature for generation, 0.0 means greedy\n def TORCH_DEVICE_MODEL(self) -> str:\n def CUDA(self) -> bool:\n def MODEL_DTYPE(self) -> torch.dtype:" }, { "identifier": "is_valid_image", "path": "texify/util.py", "snippet": "def is_valid_image(file_path):\n if not os.path.isfile(file_path):\n return False\n\n filename = os.path.basename(file_path)\n if filename.startswith(\".\"):\n return False\n\n try:\n with Image.open(file_path) as img:\n img.verify()\n return True\n except Exception:\n return False" } ]

[ { "identifier": "generate_conversions", "path": "src/visualization/drawing/coordinate_conversion.py", "snippet": "def generate_conversions(\n shape: tuple[int, int],\n device: torch.device,\n x_range: Optional[Pair] = None,\n y_range: Optional[Pair] = None,\n) -> tuple[\n ConversionFunction, # conversion from world coordinates to pixel coordinates\n ConversionFunction, # conversion from pixel coordinates to world coordinates\n]:\n h, w = shape\n x_range = sanitize_pair((0, w) if x_range is None else x_range, device)\n y_range = sanitize_pair((0, h) if y_range is None else y_range, device)\n minima, maxima = torch.stack((x_range, y_range), dim=-1)\n wh = torch.tensor((w, h), dtype=torch.float32, device=device)\n\n def convert_world_to_pixel(\n xy: Float[Tensor, \"*batch 2\"],\n ) -> Float[Tensor, \"*batch 2\"]:\n return (xy - minima) / (maxima - minima) * wh\n\n def convert_pixel_to_world(\n xy: Float[Tensor, \"*batch 2\"],\n ) -> Float[Tensor, \"*batch 2\"]:\n return xy / wh * (maxima - minima) + minima\n\n return convert_world_to_pixel, convert_pixel_to_world" }, { "identifier": "render_over_image", "path": "src/visualization/drawing/rendering.py", "snippet": "def render_over_image(\n image: Float[Tensor, \"3 height width\"],\n color_function: ColorFunction,\n device: torch.device,\n subdivision: int = 8,\n num_passes: int = 1,\n) -> Float[Tensor, \"3 height width\"]:\n _, h, w = image.shape\n overlay = render(\n (h, w),\n color_function,\n device,\n subdivision=subdivision,\n num_passes=num_passes,\n )\n color, alpha = overlay.split((3, 1), dim=0)\n return image * (1 - alpha) + color * alpha" }, { "identifier": "Pair", "path": "src/visualization/drawing/types.py", "snippet": "def sanitize_vector(\n vector: Vector,\n dim: int,\n device: torch.device,\n) -> Float[Tensor, \"*#batch dim\"]:\ndef sanitize_scalar(scalar: Scalar, device: torch.device) -> Float[Tensor, \"*#batch\"]:\ndef sanitize_pair(pair: Pair, device: torch.device) -> Float[Tensor, \"2\"]:" } ]

[ { "identifier": "db", "path": "model.py", "snippet": "class User(db.Model):\n def keys(self):\n def __getitem__(self, item):\n def __repr__(self):" }, { "identifier": "share_tools", "path": "util/share_tools.py", "snippet": "def get_host():\ndef get_share_token(access_token, unique_name, expires_in=0, show_conversations=False, show_userinfo=True):\ndef get_share_token_info(share_token, access_token=None):" }, { "identifier": "ApiResponse", "path": "util/api_response.py", "snippet": "class ApiResponse:\n\n @staticmethod\n def success(data):\n return jsonify({\n 'status': 0,\n 'message': '请求成功',\n 'data': data\n })\n\n @staticmethod\n def error(message, status=-1):\n return jsonify({\n 'status': status,\n 'message': message\n }), 500\n\n @staticmethod\n def unauthorized(message):\n return jsonify({\n 'status': 444,\n 'message': message\n }), 444" }, { "identifier": "sync_pandora", "path": "util/pandora_tools.py", "snippet": "def sync_pandora():\n make_json()\n fresh_setup()" } ]

[ { "identifier": "ChatInputForm", "path": "src/fastui_chat/components.py", "snippet": "class ChatInputForm(c.Form):\n \"\"\"\n Component for displaying a chat input form.\n \"\"\"\n\n fire_page_event: str\n display_mode: str = \"inline\"\n class_name: str = \"row row-cols-lg-3 justify-content-center\"\n form_fields: list[c.FormFieldInput] = [\n c.FormFieldInput(\n title=\"\",\n name=\"user_msg\",\n placeholder=\"Message ChatBot...\",\n class_name=\"py-4\",\n ),\n ]\n\n def __init__(\n self,\n *,\n submit_url: str,\n fire_page_event: str,\n **data: Any,\n ) -> None:\n data[\"submit_url\"] = submit_url\n data[\"fire_page_event\"] = fire_page_event\n super().__init__(**data, footer=[])\n self.footer = [\n c.FireEvent(event=e.PageEvent(name=self.fire_page_event)),\n ]" }, { "identifier": "ChatMessage", "path": "src/fastui_chat/components.py", "snippet": "class ChatMessage(c.Div):\n \"\"\"\n Component for displaying a chat message.\n \"\"\"\n\n content: Union[str, list[Union[str, dict]]]\n msg_type: Literal[\"human\", \"ai\"]\n class_name: str = \"container col-sm-4 my-4\"\n display_alias: DisplayAlias = {\"human\": \"You\", \"ai\": \"ChatBot\"}\n\n @property\n def images(self) -> list[str]:\n \"\"\"Return a list of image URLs in the message content.\"\"\"\n if isinstance(self.content, str):\n return []\n return [\n (\n item[\"image_url\"][\"url\"]\n if isinstance(item[\"image_url\"], dict)\n else item[\"image_url\"]\n )\n for item in self.content\n if isinstance(item, dict) and item[\"type\"] == \"image_url\"\n ]\n\n @property\n def message(self) -> str:\n \"\"\"Return the message content.\"\"\"\n return (\n self.content\n if isinstance(self.content, str)\n else self.content[0]\n if isinstance(self.content[0], str)\n else self.content[0][\"text\"]\n )\n\n def __init__(\n self,\n msg_type: Literal[\"human\", \"ai\"],\n content: Union[str, list[Union[str, dict]]],\n **data: Any,\n ) -> None:\n if msg_type == \"AIMessageChunk\":\n msg_type = \"ai\"\n data[\"msg_type\"] = msg_type\n data[\"content\"] = content\n super().__init__(**data, components=[])\n self.components = [\n c.Heading(text=self.display_alias[self.msg_type], level=6),\n c.Markdown(text=self.message),\n *(\n c.Image(\n src=image_url,\n class_name=\"img-fluid\",\n )\n for image_url in self.images\n ),\n ]" }, { "identifier": "get_history", "path": "src/fastui_chat/db.py", "snippet": "async def get_history() -> AsyncGenerator[BaseChatMessageHistory, None]:\n if \"chat_history\" not in database:\n raise RuntimeError(\"Database not initialized\")\n yield database[\"chat_history\"]" }, { "identifier": "get_session", "path": "src/fastui_chat/db.py", "snippet": "async def get_session() -> AsyncGenerator[ChatSession, None]:\n if \"chat_history\" not in database or \"chat_handler\" not in database:\n raise RuntimeError(\"Database not initialized\")\n yield ChatSession(\n history=database[\"chat_history\"],\n chat_handler=database[\"chat_handler\"],\n )" }, { "identifier": "ChatSession", "path": "src/fastui_chat/session.py", "snippet": "class ChatSession:\n def __init__(\n self,\n *,\n chat_handler: Runnable[HumanMessage, AIMessage],\n history: BaseChatMessageHistory,\n ) -> None:\n self.history = history\n self.chat_handler = chat_handler\n\n async def astream(self, user_msg: str):\n async for message in self.chat_handler.astream(\n HumanMessage(content=user_msg),\n config={\n \"run_name\": \"ChatMessage\",\n \"configurable\": {\"session_id\": \"\"},\n },\n ):\n yield message" } ]

[ { "identifier": "build_vision_tower", "path": "vcoder_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": "vcoder_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 return nn.Sequential(*modules)\n\n if projector_type == 'identity':\n return IdentityMap()\n\n raise ValueError(f'Unknown projector type: {projector_type}')" }, { "identifier": "build_seg_projector", "path": "vcoder_llava/model/multimodal_adapter/builder.py", "snippet": "def build_seg_projector(config, delay_load=False, **kwargs):\n projector_type = getattr(config, 'seg_mm_projector_type', 'linear')\n\n if projector_type == 'linear':\n return nn.Linear(config.seg_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.seg_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 return nn.Sequential(*modules)\n\n if projector_type == 'identity':\n return IdentityMap()\n\n raise ValueError(f'Unknown seg projector type: {projector_type}')" }, { "identifier": "build_depth_projector", "path": "vcoder_llava/model/multimodal_depth_adapter/builder.py", "snippet": "def build_depth_projector(config, delay_load=False, **kwargs):\n projector_type = getattr(config, 'depth_mm_projector_type', 'linear')\n\n if projector_type == 'linear':\n return nn.Linear(config.depth_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.depth_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 return nn.Sequential(*modules)\n\n if projector_type == 'identity':\n return IdentityMap()\n\n raise ValueError(f'Unknown depth projector type: {projector_type}')" }, { "identifier": "IGNORE_INDEX", "path": "vcoder_llava/constants.py", "snippet": "IGNORE_INDEX = -100" }, { "identifier": "IMAGE_TOKEN_INDEX", "path": "vcoder_llava/constants.py", "snippet": "IMAGE_TOKEN_INDEX = -200" }, { "identifier": "SEG_TOKEN_INDEX", "path": "vcoder_llava/constants.py", "snippet": "SEG_TOKEN_INDEX = -300" }, { "identifier": "DEPTH_TOKEN_INDEX", "path": "vcoder_llava/constants.py", "snippet": "DEPTH_TOKEN_INDEX = -400" } ]

[ { "identifier": "Function", "path": "microchain/engine/function.py", "snippet": "class Function:\n def __init__(self):\n self.call_signature = inspect.signature(self.__call__) \n self.call_parameters = []\n for name, parameter in self.call_signature.parameters.items():\n if parameter.annotation == inspect._empty:\n raise ValueError(f\"Parameter {name} must have an annotation\")\n \n self.call_parameters.append(dict(\n name=name,\n annotation=parameter.annotation\n ))\n self.state = None\n self.engine = None\n \n def bind(self, *, state, engine):\n self.state = state\n self.engine = engine\n\n @property\n def name(self):\n return type(self).__name__\n\n @property\n def example(self):\n if not isinstance(self.example_args, list):\n raise ValueError(\"example_args must be a list\")\n if len(self.example_args) != len(self.call_parameters):\n raise ValueError(f\"example_args must have the same length as call_parameters ({len(self.call_parameters)})\")\n\n bound = self.call_signature.bind(*self.example_args)\n \n return f\"{self.name}({', '.join([f'{name}={value}' for name, value in bound.arguments.items()])})\"\n \n @property\n def signature(self):\n arguments = [f\"{parameter['name']}: {parameter['annotation'].__name__}\" for parameter in self.call_parameters]\n return f\"{self.name}({', '.join(arguments)})\"\n\n @property\n def help(self):\n return f\"{self.signature}\\n{self.description}.\\nExample: {self.example}\\n\"\n\n @property\n def error(self):\n return f\"Error: wrong format. Use {self.signature}. Example: {self.example}. Please try again.\"\n\n def check_bind(self):\n if self.state is None:\n raise ValueError(\"You must register the function to an Engine\")\n\n def safe_call(self, args, kwargs):\n self.check_bind()\n try:\n return FunctionResult.SUCCESS, str(self.__call__(*args, **kwargs))\n except Exception as e:\n print(colored(f\"Exception in Function call {e}\", \"red\"))\n print(colored(''.join(traceback.TracebackException.from_exception(e).format()), \"red\"))\n return FunctionResult.ERROR, self.error\n\n def __call__(self, command):\n raise NotImplementedError" }, { "identifier": "FunctionResult", "path": "microchain/engine/function.py", "snippet": "class FunctionResult(enum.Enum):\n SUCCESS = 0\n ERROR = 1" } ]

[ { "identifier": "get_tree_repr", "path": "src/data_utils/dom_utils.py", "snippet": "def get_tree_repr(\n tree, max_value_length=5, max_length=20, id_mapping={}, keep_html_brackets=False\n):\n if isinstance(tree, str):\n tree = etree.fromstring(tree)\n else:\n tree = copy.deepcopy(tree)\n for node in tree.xpath(\"//*\"):\n if node.tag != \"text\":\n if \"backend_node_id\" in node.attrib:\n if node.attrib[\"backend_node_id\"] not in id_mapping:\n id_mapping[node.attrib[\"backend_node_id\"]] = len(id_mapping)\n node.attrib[\"backend_node_id\"] = str(\n id_mapping[node.attrib[\"backend_node_id\"]]\n )\n get_attribute_repr(node, max_value_length, max_length)\n else:\n node.text = \" \".join(node.text.split()[:max_length])\n tree_repr = etree.tostring(tree, encoding=\"unicode\")\n\n tree_repr = tree_repr.replace('\"', \" \")\n tree_repr = (\n tree_repr.replace(\"meta= \", \"\").replace(\"id= \", \"id=\").replace(\" >\", \">\")\n )\n tree_repr = re.sub(r\"<text>(.*?)</text>\", r\"\\1\", tree_repr)\n if not keep_html_brackets:\n tree_repr = tree_repr.replace(\"/>\", \"$/$>\")\n tree_repr = re.sub(r\"</(.+?)>\", r\")\", tree_repr)\n tree_repr = re.sub(r\"<(.+?)>\", r\"(\\1\", tree_repr)\n tree_repr = tree_repr.replace(\"$/$\", \")\")\n\n html_escape_table = [\n (\"&quot;\", '\"'),\n (\"&amp;\", \"&\"),\n (\"&lt;\", \"<\"),\n (\"&gt;\", \">\"),\n (\"&nbsp;\", \" \"),\n (\"&ndash;\", \"-\"),\n (\"&rsquo;\", \"'\"),\n (\"&lsquo;\", \"'\"),\n (\"&ldquo;\", '\"'),\n (\"&rdquo;\", '\"'),\n (\"&#39;\", \"'\"),\n (\"&#40;\", \"(\"),\n (\"&#41;\", \")\"),\n ]\n for k, v in html_escape_table:\n tree_repr = tree_repr.replace(k, v)\n tree_repr = re.sub(r\"\\s+\", \" \", tree_repr).strip()\n\n return tree_repr, id_mapping" }, { "identifier": "data_prune_tree", "path": "src/data_utils/dom_utils.py", "snippet": "def data_prune_tree(\n dom_tree,\n candidate_set,\n max_depth=5,\n max_children=50,\n max_sibling=3,\n):\n nodes_to_keep = set()\n for candidate_id in candidate_set:\n candidate_node = dom_tree.xpath(f'//*[@backend_node_id=\"{candidate_id}\"]')[0]\n nodes_to_keep.add(candidate_node.attrib[\"backend_node_id\"])\n # get all ancestors\n nodes_to_keep.update(\n [\n x.attrib.get(\"backend_node_id\", \"\")\n for x in candidate_node.xpath(\"ancestor::*\")\n ]\n )\n # get descendants with max depth\n nodes_to_keep.update(\n [\n x.attrib.get(\"backend_node_id\", \"\")\n for x in get_descendants(candidate_node, max_depth)\n ][:max_children]\n )\n # get siblings within range\n parent = candidate_node.getparent()\n if parent is not None:\n siblings = [x for x in parent.getchildren() if x.tag != \"text\"]\n idx_in_sibling = siblings.index(candidate_node)\n nodes_to_keep.update(\n [\n x.attrib.get(\"backend_node_id\", \"\")\n for x in siblings[\n max(0, idx_in_sibling - max_sibling): idx_in_sibling\n + max_sibling\n + 1\n ]\n ]\n )\n # clone the tree\n new_tree = copy.deepcopy(dom_tree)\n # remove nodes not in nodes_to_keep\n for node in new_tree.xpath(\"//*\")[::-1]:\n if node.tag != \"text\":\n is_keep = node.attrib.get(\"backend_node_id\", \"\") in nodes_to_keep\n is_candidate = node.attrib.get(\"backend_node_id\", \"\") in candidate_set\n else:\n is_keep = (\n node.getparent().attrib.get(\"backend_node_id\", \"\") in nodes_to_keep\n )\n is_candidate = (\n node.getparent().attrib.get(\"backend_node_id\", \"\") in candidate_set\n )\n if not is_keep and node.getparent() is not None:\n node.getparent().remove(node)\n else:\n if not is_candidate or node.tag == \"text\":\n node.attrib.pop(\"backend_node_id\", None)\n if (\n len(node.attrib) == 0\n and not any([x.tag == \"text\" for x in node.getchildren()])\n and node.getparent() is not None\n and node.tag != \"text\"\n and len(node.getchildren()) <= 1\n ):\n # insert all children into parent\n for child in node.getchildren():\n node.addprevious(child)\n node.getparent().remove(node)\n return new_tree, nodes_to_keep" } ]

[ { "identifier": "get_mase_op", "path": "machop/chop/passes/graph/utils.py", "snippet": "def get_mase_op(node):\n return node.meta[\"mase\"].parameters[\"common\"][\"mase_op\"]" }, { "identifier": "get_mase_type", "path": "machop/chop/passes/graph/utils.py", "snippet": "def get_mase_type(node):\n return node.meta[\"mase\"].parameters[\"common\"][\"mase_type\"]" }, { "identifier": "SOFTWARE_PARAM_ANALYSIS_LAYERS", "path": "machop/chop/passes/graph/analysis/add_metadata/software_metadata_layers.py", "snippet": "SOFTWARE_PARAM_ANALYSIS_LAYERS = {\n \"module\": {\n \"batch_norm1d\": analyze_software_meta_param_nn_module_batch_norm,\n \"batch_norm2d\": analyze_software_meta_param_nn_module_batch_norm,\n # default:\n \"default\": analyze_software_meta_param_nn_module_default,\n },\n \"module_related_func\": {\n \"adaptive_avg_pool1d\": analyze_software_meta_param_module_related_func_default,\n \"adaptive_avg_pool2d\": analyze_software_meta_param_module_related_func_default,\n \"adaptive_max_pool1d\": analyze_software_meta_param_module_related_func_default,\n \"adaptive_max_pool2d\": analyze_software_meta_param_module_related_func_default,\n \"avg_pool1d\": analyze_software_meta_param_module_related_func_default,\n \"avg_pool2d\": analyze_software_meta_param_module_related_func_default,\n \"batch_norm\": analyze_software_meta_param_module_related_func_default,\n \"conv1d\": analyze_software_meta_param_module_related_func_default,\n \"conv2d\": analyze_software_meta_param_module_related_func_default,\n \"layer_norm\": analyze_software_meta_param_module_related_func_default,\n \"linear\": analyze_software_meta_param_module_related_func_default,\n \"max_pool1d\": analyze_software_meta_param_module_related_func_default,\n \"max_pool2d\": analyze_software_meta_param_module_related_func_default,\n \"relu\": analyze_software_meta_param_module_related_func_default,\n # NOTE: These ops were added to support MobileNetV2 and MobileNetV3\n \"relu6\": analyze_software_meta_param_module_related_func_default,\n \"hardswish\": analyze_software_meta_param_module_related_func_default,\n \"hardsigmoid\": analyze_software_meta_param_module_related_func_default,\n \"dropout\": analyze_software_meta_param_module_related_func_default,\n # default:\n \"default\": analyze_software_meta_param_module_related_func_default,\n },\n # builtin func\n \"builtin_func\": {\n \"mul\": analyze_software_meta_param_builtin_func_default,\n \"sub\": analyze_software_meta_param_builtin_func_default,\n \"add\": analyze_software_meta_param_builtin_func_default,\n \"matmul\": analyze_software_meta_param_builtin_func_default,\n \"bmm\": analyze_software_meta_param_builtin_func_default,\n # default:\n \"default\": analyze_software_meta_param_builtin_func_default,\n },\n \"implicit_func\": {\n \"size\": analyze_software_meta_param_implicit_func_default,\n \"view\": analyze_software_meta_param_implicit_func_default,\n \"flatten\": analyze_software_meta_param_implicit_func_default,\n \"t\": analyze_software_meta_param_implicit_func_default,\n \"constant\": analyze_software_meta_param_implicit_func_default,\n \"default\": analyze_software_meta_param_implicit_func_default,\n \"ge\": analyze_software_meta_param_implicit_func_default,\n \"where\": analyze_software_meta_param_implicit_func_default,\n \"clamp_\": analyze_software_meta_param_implicit_func_default,\n \"abs\": analyze_software_meta_param_implicit_func_default,\n \"stack\": analyze_software_meta_param_implicit_func_default,\n \"getitem\": analyze_software_meta_param_implicit_func_default,\n \"getattr\": analyze_software_meta_param_implicit_func_default,\n },\n \"placeholder\": {\n \"placeholder\": analyze_software_meta_param_placeholder,\n },\n \"get_attr\": {\n \"get_attr\": analyze_software_meta_param_get_attr,\n },\n \"output\": {\n \"output\": analyze_software_meta_param_output,\n },\n \"patched_func\": {\n \"default\": analyze_software_meta_param_patched_func_default,\n },\n}" } ]

[ { "identifier": "GetPromptTemplates", "path": "app/prompt_templates.py", "snippet": "class GetPromptTemplates:\n def __init__(self, topic):\n self.topic = topic\n self.question_parser = CommaSeparatedListOutputParser()\n \n def ResearchPromptTemplate(self, questions = ''):\n if questions != '':\n research_bot_final_prompt = research_bot_prompt + \"\\n\\nQuestions Answered by the user : \" + questions + \"\\n\\n\" + \"Output :\\n\\n\";\n else:\n research_bot_final_prompt = research_bot_prompt + \"\\n\\n\" + \"Output :\\n\\n\";\n \n ResearchPromptTemplate = PromptTemplate(template= research_bot_final_prompt, input_variables=[\"Topic\"])\n # partial_variables={\"format_instructions\": self.research_parser.get_format_instructions()} \n return ResearchPromptTemplate.format_prompt(Topic = self.topic).to_string()\n \n def QuestionPromptTemplate(self):\n QuestionPromptTemplate = PromptTemplate(template= question_forming_prompt, input_variables=[\"Topic\"], partial_variables={\"format_instructions\": self.question_parser.get_format_instructions()})\n\n return QuestionPromptTemplate.format_prompt(Topic = self.topic).to_string()\n \n def MermaidPromptTemplate(self, information):\n MermaidPromptTemplate = PromptTemplate(template= mermaid_maker_prompt, input_variables=[\"information\"])\n\n return MermaidPromptTemplate.format_prompt(information = information).to_string()" }, { "identifier": "QuestionFraming", "path": "app/question_framing.py", "snippet": "class QuestionFraming:\n def __init__(self, question: list):\n self.question = question\n self.answer = []\n\n def ask_questions(self):\n print('\\033[91m' + \"Answer the following questions: (Leave blank if no answer)\" + '\\033[0m')\n for i in self.question:\n # print in blue color\n print('\\033[94m' + i + \"\\n > \" + '\\033[0m', end=\"\")\n answer = input()\n if answer == \"\":\n answer = \"No answer\"\n self.answer.append(answer)\n # Add more questions if needed\n\n def format_information(self):\n information = dict(zip(self.question, self.answer))\n return information" }, { "identifier": "Chains", "path": "packages/chains.py", "snippet": "class Chains:\n def __init__(self, *args):\n self._chains = args\n\n def chain(self, PromptTemplate, parser = None):\n message = [\n SystemMessage(content = PromptTemplate)\n ]\n output = llm(message)\n if parser is None:\n return output.content\n else:\n return parser.parse(output.content)" } ]

[ { "identifier": "Config", "path": "config.py", "snippet": "class Config:\n def __init__(self, config_path):\n self.config = configparser.ConfigParser()\n self.config.read(config_path, encoding='utf-8')\n\n self.config_path = config_path\n self.key = self.config.get('config', 'key')\n self.save_path = self.config.get('config', 'save_path')\n if self.save_path == '' or self.save_path is None:\n self.save_path = os.path.join(os.path.expanduser('~'), 'Downloads')\n\n self.port = int(self.config.get('config', 'port'))\n self.basic_notifier = False if self.config.get('config', 'basic_notifier')=='0' else True\n\n self.version = self.config.get('info', 'version')" }, { "identifier": "create_notifier", "path": "notifier.py", "snippet": "def create_notifier(basic: bool = True):\n return BasicNotifier() if basic else Notifier()" }, { "identifier": "Server", "path": "server.py", "snippet": "class Server:\n def __init__(self, config: Config, notifier: INotifier):\n self.config = config\n self.notifier = notifier\n self.blueprint = Blueprint('server', __name__)\n self.register_routes()\n self.app = Flask(__name__)\n self.app.register_blueprint(self.blueprint)\n\n def run(self, host: str, port: int):\n self.app.run(host=host, port=port)\n\n def register_routes(self):\n \"\"\" ----------- 统一处理 ----------- \"\"\"\n # 统一认证\n @self.blueprint.before_request\n def check_api_key():\n if request.path == '/':\n return\n auth_header = request.headers.get(\"Authorization\")\n if auth_header != self.config.key:\n return Result.error(msg='密钥错误', code=401)\n version = request.headers.get(\"ShortcutVersion\")\n if version != self.config.version:\n msg = f'版本不匹配\\n\\nWindows版本为：{self.config.version}\\n快捷指令版本为：{version}'\n return Result.error(msg=msg, code=400)\n\n # 统一异常处理\n @self.blueprint.errorhandler(Exception)\n def handle_all_exceptions(error):\n msg = str(error)\n self.notifier.notify('错误', '遇到一个错误' + msg)\n return Result.error(msg, 500)\n\n \"\"\" ----------- 测试 ----------- \"\"\"\n @self.blueprint.route('/')\n def test():\n return 'Hello world!'\n\n \"\"\" ----------- 文件 ----------- \"\"\"\n # 手机端发送接下来要发送的文件列表\n @self.blueprint.route('/file/send/list', methods=['POST'])\n def send_file_list():\n filename_list = request.form['file_list'].splitlines()\n self.notifier.show_future_files(self.config.save_path, filename_list, to_mobile=False)\n return Result.success(msg=\"发送成功\")\n\n # 手机端发送文件\n @self.blueprint.route('/file/send', methods=['POST'])\n def send_file():\n if 'file' not in request.files:\n return Result.error(msg=\"文件不存在\")\n file = request.files['file']\n ori_filename = request.form['filename']\n notify_content = request.form['notify_content']\n filename = utils.avoid_duplicate_filename(self.config.save_path, ori_filename)\n file.save(os.path.join(self.config.save_path, filename))\n\n if notify_content != '':\n ori_filename_list = notify_content.splitlines()\n if len(ori_filename_list) == 1:\n self.notifier.show_received_file(self.config.save_path, filename, ori_filename)\n else:\n self.notifier.show_received_files(self.config.save_path, ori_filename_list)\n return Result.success(msg=\"发送成功\")\n\n # 获取电脑端复制的文件的路径列表\n @self.blueprint.route('/file/receive/list')\n def receive_file_list():\n success, res = utils.get_clipboard_files()\n if not success:\n msg = f'未复制文件: {res}'\n self.notifier.notify('错误', msg)\n return Result.error(msg=msg)\n if len(res) > 0:\n file_names = [os.path.basename(path) for path in res]\n self.notifier.show_future_files(None, file_names, to_mobile=True)\n return Result.success(data=res)\n return Result.error(msg='Windows未复制文件')\n\n # 获取电脑端文件\n @self.blueprint.route('/file/receive', methods=['POST'])\n def receive_file():\n path = request.form.get('path')\n file_name = os.path.basename(path)\n # self.notifier.notify('文件', f'发送: {file_name}')\n with open(path, 'rb') as f:\n file_content = f.read()\n return flask.send_file(io.BytesIO(file_content), as_attachment=True, download_name=file_name)\n\n \"\"\" ----------- 剪贴板 ----------- \"\"\"\n # 获取电脑端剪贴板\n @self.blueprint.route('/clipboard/receive')\n def receive_clipboard():\n success, res = utils.get_clipboard_content()\n if not success:\n msg = f'获取剪贴板出错: {res}'\n self.notifier.notify('错误', msg)\n return Result.error(msg=msg)\n if res != '':\n self.notifier.notify('剪贴板', f'发送: {res}')\n return Result.success(data=res)\n else:\n self.notifier.notify('剪贴板', '发送失败: Windows剪贴板为空')\n return Result.error(msg='Windows剪贴板为空')\n\n # 接收手机端剪贴板\n @self.blueprint.route('/clipboard/send', methods=['POST'])\n def send_clipboard():\n clipboard = request.form['clipboard']\n if clipboard is None or clipboard == '':\n self.notifier.notify('剪贴板', '接收失败: iPhone剪贴板为空')\n return Result.error(msg='iPhone剪贴板为空')\n success, msg = utils.set_clipboard_content(clipboard)\n if success:\n self.notifier.notify('剪贴板', f'收到剪贴板内容: {clipboard}')\n else:\n self.notifier.notify('错误', f'设置剪贴板出错: {msg}')\n return Result.success(msg='发送成功') if success else Result.error(msg=msg)" } ]

[ { "identifier": "get_blocks", "path": "ldm/thirdp/psp/helpers.py", "snippet": "def get_blocks(num_layers):\n\tif num_layers == 50:\n\t\tblocks = [\n\t\t\tget_block(in_channel=64, depth=64, num_units=3),\n\t\t\tget_block(in_channel=64, depth=128, num_units=4),\n\t\t\tget_block(in_channel=128, depth=256, num_units=14),\n\t\t\tget_block(in_channel=256, depth=512, num_units=3)\n\t\t]\n\telif num_layers == 100:\n\t\tblocks = [\n\t\t\tget_block(in_channel=64, depth=64, num_units=3),\n\t\t\tget_block(in_channel=64, depth=128, num_units=13),\n\t\t\tget_block(in_channel=128, depth=256, num_units=30),\n\t\t\tget_block(in_channel=256, depth=512, num_units=3)\n\t\t]\n\telif num_layers == 152:\n\t\tblocks = [\n\t\t\tget_block(in_channel=64, depth=64, num_units=3),\n\t\t\tget_block(in_channel=64, depth=128, num_units=8),\n\t\t\tget_block(in_channel=128, depth=256, num_units=36),\n\t\t\tget_block(in_channel=256, depth=512, num_units=3)\n\t\t]\n\telse:\n\t\traise ValueError(\"Invalid number of layers: {}. Must be one of [50, 100, 152]\".format(num_layers))\n\treturn blocks" }, { "identifier": "Flatten", "path": "ldm/thirdp/psp/helpers.py", "snippet": "class Flatten(Module):\n\tdef forward(self, input):\n\t\treturn input.view(input.size(0), -1)" }, { "identifier": "bottleneck_IR", "path": "ldm/thirdp/psp/helpers.py", "snippet": "class bottleneck_IR(Module):\n\tdef __init__(self, in_channel, depth, stride):\n\t\tsuper(bottleneck_IR, self).__init__()\n\t\tif in_channel == depth:\n\t\t\tself.shortcut_layer = MaxPool2d(1, stride)\n\t\telse:\n\t\t\tself.shortcut_layer = Sequential(\n\t\t\t\tConv2d(in_channel, depth, (1, 1), stride, bias=False),\n\t\t\t\tBatchNorm2d(depth)\n\t\t\t)\n\t\tself.res_layer = Sequential(\n\t\t\tBatchNorm2d(in_channel),\n\t\t\tConv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False), PReLU(depth),\n\t\t\tConv2d(depth, depth, (3, 3), stride, 1, bias=False), BatchNorm2d(depth)\n\t\t)\n\n\tdef forward(self, x):\n\t\tshortcut = self.shortcut_layer(x)\n\t\tres = self.res_layer(x)\n\t\treturn res + shortcut" }, { "identifier": "bottleneck_IR_SE", "path": "ldm/thirdp/psp/helpers.py", "snippet": "class bottleneck_IR_SE(Module):\n\tdef __init__(self, in_channel, depth, stride):\n\t\tsuper(bottleneck_IR_SE, self).__init__()\n\t\tif in_channel == depth:\n\t\t\tself.shortcut_layer = MaxPool2d(1, stride)\n\t\telse:\n\t\t\tself.shortcut_layer = Sequential(\n\t\t\t\tConv2d(in_channel, depth, (1, 1), stride, bias=False),\n\t\t\t\tBatchNorm2d(depth)\n\t\t\t)\n\t\tself.res_layer = Sequential(\n\t\t\tBatchNorm2d(in_channel),\n\t\t\tConv2d(in_channel, depth, (3, 3), (1, 1), 1, bias=False),\n\t\t\tPReLU(depth),\n\t\t\tConv2d(depth, depth, (3, 3), stride, 1, bias=False),\n\t\t\tBatchNorm2d(depth),\n\t\t\tSEModule(depth, 16)\n\t\t)\n\n\tdef forward(self, x):\n\t\tshortcut = self.shortcut_layer(x)\n\t\tres = self.res_layer(x)\n\t\treturn res + shortcut" }, { "identifier": "l2_norm", "path": "ldm/thirdp/psp/helpers.py", "snippet": "def l2_norm(input, axis=1):\n\tnorm = torch.norm(input, 2, axis, True)\n\toutput = torch.div(input, norm)\n\treturn output" } ]

[ { "identifier": "detect_magic_size", "path": "decryptblocks.py", "snippet": "def make_int(i):\ndef make_int_or_percent(i):\ndef xor_blocks(var, key, byteorder=sys.byteorder):\ndef write_block(fd, offset, block):\ndef main():\ndef decrypt_file(f, keyblock, fsize=None, is_dry=True, lower_limit=None, upper_limit=None):\n def advise(t, start, end):\n def advise(*args, **kwargs):\nclass Percent(int):\nGB = 1024*1024*1024\nBLOCK_SIZE = 64\n BLOCK_SIZE = len(null)" }, { "identifier": "ranges_for_file", "path": "ranges.py", "snippet": "def ranges_for_file(path, fsize=None):\n #return ranges_for_file_real(path)\n if fsize is None:\n return ranges_for_file_generated(path)\n else:\n return ranges_for_file_size(fsize)" } ]

[ { "identifier": "Banner", "path": "seashell/utils/ui/banner.py", "snippet": "class Banner(object):\n \"\"\" Subclass of seashell.core module.\n\n This subclass of seashell.core module is intended for\n providing tools for printing banners in UI.\n \"\"\"\n\n def __init__(self) -> None:\n super().__init__()\n\n self.config = Config()\n\n self.badges = Badges()\n self.color_script = ColorScript()\n\n def print_random_banner(self) -> None:\n \"\"\" Print random banner.\n\n :return None: None\n \"\"\"\n\n if os.path.exists(self.config.banners_path):\n banners = []\n all_banners = os.listdir(self.config.banners_path)\n\n for banner in all_banners:\n banners.append(banner)\n\n if banners:\n banner = \"\"\n\n while not banner:\n random_banner = random.randint(0, len(banners) - 1)\n banner = self.color_script.parse_file(\n self.config.banners_path + banners[random_banner]\n )\n\n self.badges.print_empty(f\"%newline%end{banner}%end%newline\")\n else:\n self.badges.print_warning(\"No banners detected.\")\n else:\n self.badges.print_warning(\"No banners detected.\")" }, { "identifier": "Tip", "path": "seashell/utils/ui/tip.py", "snippet": "class Tip(object):\n \"\"\" Subclass of seashell.core module.\n\n This subclass of seashell.core module is intended for\n providing tools for printing tips in UI.\n \"\"\"\n\n def __init__(self) -> None:\n super().__init__()\n\n self.config = Config()\n\n self.badges = Badges()\n self.color_script = ColorScript()\n\n def print_random_tip(self) -> None:\n \"\"\" Print random tip.\n\n :return None: None\n \"\"\"\n\n if os.path.exists(self.config.tips_path):\n tips = []\n all_tips = os.listdir(self.config.tips_path)\n\n for tip in all_tips:\n tips.append(tip)\n\n if tips:\n tip = \"\"\n\n while not tip:\n random_tip = random.randint(0, len(tips) - 1)\n tip = self.color_script.parse_file(\n self.config.tips_path + tips[random_tip]\n )\n\n self.badges.print_empty(f\"%newline%endSeaShell Tip: {tip}%end%newline\")\n else:\n self.badges.print_warning(\"No tips detected.\")\n else:\n self.badges.print_warning(\"No tips detected.\")" }, { "identifier": "Config", "path": "seashell/lib/config.py", "snippet": "class Config(object):\n \"\"\" Subclass of seashell.core module.\n\n This subclass of seashell.core module is intended for providing\n basic configuration for SeaShell.\n \"\"\"\n\n def __init__(self) -> None:\n super().__init__()\n\n self.user_path = f'{pathlib.Path.home()}/.seashell/'\n self.base_path = f'{os.path.dirname(os.path.dirname(__file__))}/'\n self.data_path = self.base_path + 'data/'\n\n self.banners_path = self.data_path + 'banners/'\n self.tips_path = self.data_path + 'tips/'\n\n self.modules_path = self.base_path + 'modules/'\n self.plugins_path = self.base_path + 'plugins/'\n self.commands_path = self.base_path + 'commands/'\n\n self.loot_path = self.user_path + 'loot/'\n\n def setup(self) -> None:\n \"\"\" Setup config and create paths.\n\n :return None: None\n \"\"\"\n\n if not os.path.exists(self.user_path):\n os.mkdir(self.user_path)\n\n if not os.path.exists(self.loot_path):\n os.mkdir(self.loot_path)" } ]

[ { "identifier": "Trainer", "path": "train_utils.py", "snippet": "class Trainer(transformers.Trainer):\n \"\"\"Use CosineAnnealingLR from pytorch \n \"\"\"\n \n def create_scheduler(self, num_training_steps: int, optimizer: torch.optim.Optimizer = None):\n \"\"\"\n Setup the scheduler. The optimizer of the trainer must have been set up either before this method is called or\n passed as an argument.\n\n Args:\n num_training_steps (int): The number of training steps to do.\n \"\"\"\n if self.lr_scheduler is None:\n num_warmup_steps=self.args.get_warmup_steps(num_training_steps)\n if getattr(self.args, 'use_cosine_anneal_with_warmup', False):\n lr_max=1\n lr_min=1e-1\n cosine_anneal_with_warmup = lambda cur_iter: max(cur_iter / num_warmup_steps, 1e-9) if cur_iter < num_warmup_steps else \\\n (lr_min + 0.5*(lr_max-lr_min)*(1.0+math.cos((cur_iter-num_warmup_steps)/(num_training_steps-num_warmup_steps)*math.pi)))\n \n self.lr_scheduler = torch.optim.lr_scheduler.LambdaLR(\n optimizer=self.optimizer if optimizer is None else optimizer, \n lr_lambda=cosine_anneal_with_warmup,\n )\n else:\n self.lr_scheduler = get_scheduler(\n self.args.lr_scheduler_type,\n optimizer=self.optimizer if optimizer is None else optimizer,\n num_warmup_steps=num_warmup_steps,\n num_training_steps=num_training_steps,\n )\n self._created_lr_scheduler = True\n return self.lr_scheduler" }, { "identifier": "DEFAULT_PAD_TOKEN", "path": "datamodule/constants.py", "snippet": "DEFAULT_PAD_TOKEN = \"[PAD]\"" }, { "identifier": "DEFAULT_EOS_TOKEN", "path": "datamodule/constants.py", "snippet": "DEFAULT_EOS_TOKEN = \"<|endoftext|>\"" }, { "identifier": "DEFAULT_BOS_TOKEN", "path": "datamodule/constants.py", "snippet": "DEFAULT_BOS_TOKEN = \"<|endoftext|>\"" }, { "identifier": "TacoDataset", "path": "datamodule/taco_dataset.py", "snippet": "class TacoDataset(Dataset):\n \"\"\"Dataset for fine-tune.\"\"\"\n \n def __init__(self, data_path: str, debug: bool=False, learning_skill: int=None):\n super(TacoDataset, self).__init__()\n logging.warning(\"Loading tokenized data...\")\n if os.path.exists(data_path):\n dataset = load_from_disk(data_path).shuffle()\n else:\n raise ValueError(\" The specified data_path does not exist. Please provide a tokenized dataset\")\n \n if not all(key in dataset.column_names for key in ['input_ids', 'source_ids_lens']):\n raise ValueError(\"Data has not been tokenized. Please tokenize the data first.\")\n if debug:\n dataset = dataset.select(range(1000))\n if learning_skill:\n dataset = dataset.filter(lambda entry: entry['labels'][learning_skill])\n \n logging.warning(\"Collect columns of hf dataset... This may take some time...\")\n input_ids = dataset['input_ids']\n source_ids_lens = dataset['source_ids_lens']\n \n self.learning_skill = None\n if learning_skill:\n scores = dataset['scores']\n scores = preprocess_scores(scores, source_ids_lens, learning_skill)\n self.scores = scores\n self.learning_skill = learning_skill\n \n logging.warning(\"Processing inputs...\")\n data_dict = preprocess(input_ids, source_ids_lens)\n \n self.input_ids = data_dict[\"input_ids\"]\n self.labels = data_dict[\"labels\"]\n\n def __len__(self):\n return len(self.input_ids)\n\n def __getitem__(self, i) -> Dict[str, torch.Tensor]:\n if self.learning_skill:\n return dict(input_ids=self.input_ids[i], labels=self.labels[i], scores=self.scores[i])\n else:\n return dict(input_ids=self.input_ids[i], labels=self.labels[i])" }, { "identifier": "DataCollatorForTacoDataset", "path": "datamodule/taco_dataset.py", "snippet": "class DataCollatorForTacoDataset(object):\n \"\"\"Collate examples for fine-tune.\"\"\"\n\n tokenizer: transformers.PreTrainedTokenizer\n\n def __call__(self, instances: Sequence[Dict]) -> Dict[str, torch.Tensor]:\n input_ids, labels = tuple([instance[key] for instance in instances] for key in (\"input_ids\", \"labels\"))\n input_ids = torch.nn.utils.rnn.pad_sequence(\n input_ids, batch_first=True, padding_value=self.tokenizer.pad_token_id\n )\n labels = torch.nn.utils.rnn.pad_sequence(labels, batch_first=True, padding_value=IGNORE_INDEX)\n return dict(\n input_ids=input_ids,\n labels=labels,\n )" } ]